Skip to content

Claude Code

131 posts with the tag “Claude Code”

CLIProxyAPI Transform Your AI Subscriptions into Universal API Endpoints

CLIProxyAPI: Transform Your AI Subscriptions into Universal API Endpoints

Section titled “CLIProxyAPI: Transform Your AI Subscriptions into Universal API Endpoints”

In the rapidly evolving landscape of AI coding tools, developers often face a fragmentation problem: premium subscriptions are locked behind OAuth authentication, while many tools and SDKs expect standard API keys. CLIProxyAPI elegantly solves this bridge by converting OAuth-based AI services into universal API endpoints.

CLIProxyAPI

CLIProxyAPI is an open-source proxy server written in Go that wraps multiple AI CLI tools and exposes them through standardized API interfaces. It transforms your existing AI subscriptions into OpenAI/Gemini/Claude-compatible APIs, eliminating the need for separate API keys.

Project: router-for-me/CLIProxyAPI License: MIT Language: Go (99.7%)

CLIProxyAPI supports OAuth authentication for leading AI services:

  • Claude Code - Anthropic’s Claude models via OAuth
  • ChatGPT / OpenAI Codex - GPT series models
  • Gemini CLI - Google’s Gemini models
  • Qwen Code - Alibaba’s Qwen models
  • iFlow - Additional AI service support
  • Antigravity - Alternative AI provider

The proxy provides standardized endpoints compatible with:

  • OpenAI API format
  • Gemini API format
  • Claude API format
  • Codex API format

This means your existing OpenAI SDK code works without modification—just change the base URL.

  • Multi-account support with round-robin load balancing
  • Hot reload configuration changes take effect without restart
  • OAuth session management with automatic token refresh
  • Model mapping for intelligent fallback (e.g., claude-opus-4.5claude-sonnet-4)
  • Streaming and non-streaming responses
  • Function calling / tools support
  • Multimodal input (text and images)
  • Management API for runtime configuration
  • Reusable Go SDK for embedding
  • Docker containerization support

Prerequisites, Installation and Configuration

Section titled “Prerequisites, Installation and Configuration”
  • Go 1.21+ (for building from source)
  • Docker (optional, for containerized deployment)
  • Valid subscriptions for supported AI services
Terminal window
git clone https://github.com/router-for-me/CLIProxyAPI.git
cd CLIProxyAPI
go build -o cliproxyapi cmd/server/main.go
./cliproxyapi
Terminal window
docker run -d -p 8080:8080 router-for-me/cliproxyapi:latest

Download from the Releases page (393 releases available).

  1. Configure OAuth Providers

Edit the configuration file to add your OAuth accounts:

providers:
claude:
type: oauth
accounts:
- email: "your@email.com"
# OAuth flow will prompt for authentication
gemini:
type: oauth
accounts:
- email: "your@gmail.com"
openai:
type: oauth
accounts:
- email: "your@outlook.com"
  1. Start the Server
Terminal window
./cliproxyapi --config config.yaml
  1. Use Standard OpenAI SDK
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:8080/v1",
api_key="any-key-ignored" # OAuth handles auth
)
response = client.chat.completions.create(
model="claude-opus-4.5",
messages=[{"role": "user", "content": "Hello!"}]
)

Use your Claude Code or ChatGPT subscription with tools that only support API keys:

  • Claude Code desktop app
  • Cline VS Code extension
  • Roo Code assistant
  • Continue.dev autopilot

Distribute requests across multiple accounts to maximize usage limits:

load_balancing:
strategy: round_robin
accounts:
- account1@example.com
- account2@example.com
- account3@example.com

Leverage free-tier subscriptions from multiple providers:

  • Google Gemini (free tier available)
  • Claude Code subscription
  • OpenAI ChatGPT Plus
  1. Security First: Management endpoints are localhost-only by design
  2. Model Fallback: Configure intelligent model mapping for availability
  3. Monitor Usage: Use the Management API to track account quotas
  4. Hot Reload: Modify configuration without service interruption

CLIProxyAPI has inspired a rich ecosystem of companion tools:

ProjectDescription
vibeproxyNative macOS menu bar app for Claude Code & ChatGPT
ProxyPalmacOS GUI for managing CLIProxyAPI configuration
QuotioMenu bar app with quota tracking and auto-failover
CodMateSwiftUI app for CLI AI session management
Subtitle TranslatorBrowser-based subtitle translation tool
AspectCLIProxyAPIDirect API Keys
CostUses existing subscriptionsSeparate billing
AuthenticationOAuth (no keys to manage)API key management
Multi-providerUnified endpointSeparate SDKs needed
Load balancingBuilt-inManual implementation
FeatureCLIProxyAPIAlternatives
OAuth Providers6+ supportedUsually 1-2
Open SourceMIT LicenseOften proprietary
Go SDKEmbeddableStandalone only
DocumentationEnglish + ChineseEnglish only

Q: OAuth token expires frequently

A: CLIProxyAPI handles automatic token refresh. Ensure your OAuth credentials are valid and check system time synchronization.

Q: Model not available

A: Use model mapping to route unavailable models to alternatives:

model_mappings:
claude-opus-4.5: claude-sonnet-4

Q: Rate limiting errors

A: Enable multi-account load balancing to distribute requests across accounts.

  • Management API endpoints bind to localhost only
  • OAuth tokens are stored securely
  • Never expose your proxy to public internet without authentication
  • Regular audit logs track all API requests
  1. Check logs: tail -f cliproxyapi.log
  2. Verify OAuth sessions via Management API
  3. Test with simple curl command first
  4. Ensure firewall allows localhost communication

CLIProxyAPI represents a pragmatic solution to AI service fragmentation, transforming OAuth-based subscriptions into universal API endpoints. Whether you’re integrating with coding tools, balancing load across accounts, or simply avoiding API key management, CLIProxyAPI provides a robust, open-source foundation.

With active development (1,239+ commits), comprehensive documentation in both English and Chinese, and a growing ecosystem of companion tools, CLIProxyAPI is poised to become an essential utility in the AI developer’s toolkit.


Cover Image Source: CLIProxyAPI GitHub


Publication Summary - 2026-01-04

Blog post successfully created and published about CLIProxyAPI, covering:

  • Multi-provider OAuth integration (Claude, Gemini, ChatGPT, Qwen, iFlow)
  • Universal API compatibility with OpenAI/Gemini/Claude formats
  • Multi-account load balancing and management features
  • Installation via source, Docker, or pre-built binaries
  • Ecosystem of related projects (vibeproxy, ProxyPal, Quotio, CodMate)
  • Security considerations and troubleshooting guide

Status: Published to bilingual blog (English/Chinese)

CodMate: The Ultimate macOS Session Manager for CLI AI Tools

If you’re a developer who uses CLI-based AI tools like Claude Code, Codex, or Gemini CLI, you know the pain of managing hundreds of scattered session files. Finding that brilliant solution from last Tuesday, resuming a suspended project context, or even just reviewing what you accomplished can be frustrating.

Enter CodMate—a native macOS SwiftUI application that brings order to your AI coding chaos. Built with performance in mind and designed for developers who value their time, CodMate transforms how you interact with your AI programming assistants.

CodMate is a session manager for CLI AI tools that provides:

  • Multi-source session browsing supporting Codex, Claude Code, and Gemini CLI
  • Blazing-fast search with incremental indexing and caching
  • Compact three-column UI designed for efficient workflow
  • “Ship it” workflows like Project Review with Git Changes
  • One-click Resume/New functionality

Built with Swift 6 and SwiftUI, CodMate leverages macOS 13.5+ APIs to deliver a truly native experience with universal binary support (Apple Silicon + Intel).

CodMate’s global search panel (⌘F) offers scoped search with progress/cancel capabilities, plus quick list filtering. The app uses:

  • Memory-mapped reads for fast path indexing
  • Incremental parsing (first ~64 lines + tail sampling)
  • Background enrichment with constrained task groups
  • Chunked full-text search (128 KB) that avoids loading entire files

Keep your work organized with:

  • Projects that group sessions by repository
  • Tasks that group sessions by goal
  • Shareable task context files for team collaboration
  • Auto-assignment for new sessions in active projects

Resume sessions directly into your preferred terminal:

  • Terminal.app
  • iTerm2
  • Warp
  • Embedded terminal (non-sandbox builds)

One of CodMate’s most powerful features is the Project Review mode, which shows:

  • Changed files with stage/unstage support
  • Unified diff or raw preview
  • Commit UI with AI-powered commit message generation
  • On-demand repo authorization

CodMate includes comprehensive MCP server support:

  • Uni-Import (paste/drag JSON configuration)
  • Per-server enable toggles
  • Per-target toggles (Codex/Claude/Gemini)
  • Connectivity testing
  • Automatic export to ~/.claude/settings.json

Latest version: 0.4.2

Download for Apple Silicon | Download for Intel Mac

  • macOS 13.5 or later
  • Swift 6 toolchain
  • Xcode Command Line Tools
  • Your preferred AI CLI (Codex / Claude / Gemini) installed

CodMate is built with clean architecture principles:

├── models/ # Data models (pure types)
├── services/ # IO + indexing + integrations
├── views/ # SwiftUI views (no business logic)
├── utils/ # Helper utilities
├── payload/ # Bundled presets
├── notify/ # CLI helper (codmate-notify)
└── SwiftTerm/ # Embedded terminal dependency

Performance highlights:

  • Persistent SQLite index for fast launches
  • Actor-based services for safe concurrency
  • Cancel-able tasks with proper cancellation guards
  • File IO prefers memory-mapped data and chunked reads
ShortcutAction
⌘,Settings
⌘FGlobal Search
⌘RRefresh
⌘1Toggle sidebar
⌘2Toggle session list
FeatureCodMateTerminal-onlyWeb-based alternatives
Native macOS performance
Multi-CLI support
Visual session browsing
Project organizationPartial
Git integrationPartial
Offline-first
Privacy (local-only)

You remember generating a brilliant algorithm solution last week, but can’t recall which session it was in. With CodMate:

  1. Press ⌘F for global search
  2. Type a keyword from the solution
  3. Results appear instantly with context snippets
  4. Click to view the full conversation

Starting a new workday on a project:

  1. Open CodMate and select your project from the sidebar
  2. See all related sessions grouped by task
  3. Review yesterday’s progress in the timeline
  4. One-click Resume to continue exactly where you left off

Ready to commit your AI-assisted changes:

  1. Open Project Review mode
  2. See all changed files with diffs
  3. Stage/unstage as needed
  4. Use AI to generate a descriptive commit message
  5. Commit without leaving the app
  • macOS-only: No Windows or Linux support currently planned
  • CLI dependency: Requires the underlying CLI tools to be installed separately
  • Sandbox considerations: Some features (embedded terminal, direct file access) are limited in sandboxed builds

Understanding where CodMate stores data:

~/.codmate/
├── projects/ # Project metadata
├── tasks/ # Task metadata
├── notes/ # Session renames/comments
├── providers.json # Custom provider registry
├── mcp-servers.json # MCP server configuration
└── sessionIndex-v4.db # SQLite index cache

Q: Does CodMate modify my session files?

A: No, CodMate only reads session files. Notes, project assignments, and other metadata are stored separately.

Q: Can I use CodMate with multiple CLI tools simultaneously?

A: Yes! CodMate supports Codex, Claude Code, and Gemini CLI concurrently.

Q: Is my session data sent anywhere?

A: CodMate is local-first. Your session data never leaves your Mac unless you explicitly use features that call external APIs (like AI commit message generation).

Q: How does CodMate handle large session files?

A: CodMate uses intelligent parsing—reading only what’s needed for display, with background enrichment for full content. This keeps the UI fast even with thousands of sessions.

CodMate is open source under the Apache-2.0 license:

  • Repository: github.com/loocor/codmate
  • License: Apache-2.0
  • Build: SwiftPM-only, no Xcode project required
  • Language: Swift 99.1%
Terminal window
# Clone the repository
git clone https://github.com/loocor/codmate.git
cd codmate
# Build and run
make run
# Create distributable app bundle
make app VER=1.0.0
# Create notarized DMG
make dmg VER=1.0.0

CodMate fills a crucial gap in the AI programming workflow by providing a professional-grade interface for managing the hundreds or thousands of conversations we have with our AI assistants. If you live in the terminal with Claude Code, Codex, or Gemini CLI, CodMate is the tool that brings order to the chaos—letting you focus on building rather than hunting for that one perfect response from last week.

Advent of Claude: 31 Days of Claude Code

Throughout December, I shared one Claude Code tip per day on X/Twitter and LinkedIn. What started as a simple advent calendar became a map of the features that have fundamentally changed how I write software. This post compiles all 31 tips into a comprehensive guide, reorganized from beginner essentials to advanced patterns, and adds additional context that can’t be covered in 280 characters.

Whether you’re just getting started or looking to level up with Claude Code, there’s something here for you.


Before diving into features, set up Claude Code to understand your project.

/init — Let Claude Onboard Itself Onto Your Project

Section titled “/init — Let Claude Onboard Itself Onto Your Project”

Everybody needs onboarding docs. With /init, Claude writes its own.

Claude reads your codebase and generates a CLAUDE.md file with:

  • Build and test commands
  • Key directories and their purposes
  • Code conventions and patterns
  • Important architectural decisions

This is the first thing I run in any new project.

For larger projects, you can also create a .claude/rules/ directory for modular, topic-specific instructions. Each .md file in this directory is automatically loaded as project memory alongside your CLAUDE.md. You can even use YAML frontmatter to apply rules conditionally based on file paths:

---
paths: src/api/**/*.ts
---
# API Development Rules
- All API endpoints must include input validation

Think of CLAUDE.md as your general project guide, and .claude/rules/ as focused supplements for testing, security, API design, or anything else that deserves its own file.

Want to save something to Claude’s memory without manually editing CLAUDE.md? As of Claude Code 2.0.70, just tell Claude to update the Claude.md file for you.

Just tell Claude to remember it:

“Update Claude.md: always use bun instead of npm in this project”

Keep coding without breaking your flow.

@ mentions are the fastest way to give Claude context:

  • @src/auth.ts — Add files to context instantly
  • @src/components/ — Reference entire directories
  • @mcp:github — Enable/disable MCP servers

File suggestions are ~3x faster in git repositories and support fuzzy matching. @ is the fastest path from “I need context” to “Claude has context.”


These are the commands you’ll use constantly. Commit them to muscle memory.

Don’t waste tokens asking “can you run git status?”

Just type ! followed by your bash command:

Terminal window
! git status
! npm test
! ls -la src/

The ! prefix executes bash instantly and injects the output into context. No model processing. No delay. No wasted tokens. No need for multiple terminal windows.

This seems small until you realize you’re using it fifty times a day.

Want to try a “what if we…” approach without committing to it?

Go wild. If it gets weird, press Esc twice to jump back to a clean checkpoint.

You can rewind the conversation, the code changes, or both. One thing to note here is that Bash commands run cannot be undone.

Your past prompts are searchable:

KeyAction
Ctrl+RStart reverse search
Ctrl+R (again)Cycle through matches
EnterRun it
TabEdit first

Don’t retype. Recall. This works seamlessly with slash commands too.

It’s like git stash, but for your prompt.

Ctrl+S saves your draft. Send something else. Your draft auto-restores when you’re ready.

No more copying to a scratchpad. No more losing your train of thought mid-conversation.

Claude can predict what you’ll ask next.

Finish a task, and sometimes you’ll see a grayed-out follow-up suggestion appear:

KeyAction
TabAccept and edit
EnterAccept and run immediately

Tab used to autocomplete your code. Now it autocompletes your workflow. Toggle this feature via /config.


Claude Code is a persistent development environment and optimizing it to your workflow will allow you to do so much more.

Accidentally closed your terminal? Laptop died mid-task? No problem.

Terminal window
claude --continue # Picks up your last conversation instantly
claude --resume # Shows a picker to choose any past session

Context preserved. Momentum restored. Your work is never lost. You can also customize how long sessions are preserved via the cleanupPeriodDays setting. By default it is 30 days, but you can set it as long as you want, or even 0 if you don’t want to preserve your Claude Code sessions.

Your git branches have names. Your Claude sessions should too.

Terminal window
/rename api-migration # Names your current session
/resume api-migration # Resumes by name
claude --resume api-migration # Works from the command line too

The /resume screen groups forked sessions and supports keyboard shortcuts: P for preview, R for rename.

Start a task on the web, finish it in your terminal:

Terminal window
# On claude.ai/code, start a Claude Code session
# It runs in the background while you're away
# Later, from your terminal:
claude --teleport session_abc123

This pulls and resumes the session locally. Claude at home and on the go. Also works via the Claude mobile app for iOS and Android, as well as the Claude Desktop app.

Sometimes you need a record of what happened.

/export dumps your entire conversation to markdown:

  • Every prompt you sent
  • Every response Claude gave
  • Every tool call and its output

Perfect for documentation, training, or proving to your past self that yes, you did already try that approach.


These features remove friction and help you move faster.

Tired of reaching for the mouse to edit your prompts?

Type /vim and unlock full vim-style editing:

CommandAction
h j k lNavigate
ciwChange word
ddDelete line
w bJump by word
AAppend at end of line

Edit prompts at the speed of thought. Your muscle memory from decades of vim use finally pays off in an AI tool. And it’s never been easier to exit vim with Claude Code, just type /vim again.

Claude Code has a customizable status bar at the bottom of your terminal.

/statusline lets you configure what appears there:

  • Git branch and status
  • Current model
  • Token usage
  • Context window percentage
  • Custom scripts

Information at a glance means fewer interruptions to check on things manually.

Ever wonder what’s eating your context window?

Type /context to see exactly what’s consuming your tokens:

  • System prompt size
  • MCP server prompts
  • Memory files (CLAUDE.md)
  • Loaded skills and agents
  • Conversation history

When your context starts filling up, this is how you figure out where it’s going.

2023: "Check out my GitHub contribution graph"
2025: "Check out my Claude Code stats"

Type /stats to see your usage patterns, favorite models, usage streaks, and more.

Orange is the new green.

“Am I about to hit my limit?”

Terminal window
/usage Check your current usage with visual progress bars
/extra-usage Purchase additional capacity

Know your limits. Then exceed them.


Control how Claude approaches problems.

Trigger extended thinking on demand with a single keyword:

> ultrathink: design a caching layer for our API

When you include ultrathink in your prompt, Claude allocates up to 32k tokens for internal reasoning before responding. For complex architectural decisions or tricky debugging sessions, this can be the difference between a surface-level answer and genuine insight.

In the past you were able to specify think, think harder, and ultrathink to allocate different amounts of tokens for thinking, but we’ve since simplified this into a single thinking budget. The ultrathink keyword only works when MAX_THINKING_TOKENS is not set. When MAX_THINKING_TOKENS is configured, it takes priority and controls the thinking budget for all requests.

Clear the fog of war first.

Press Shift+Tab twice to enter Plan mode. Claude can:

  • Read and search your codebase
  • Analyze architecture
  • Explore dependencies
  • Draft implementation plans

But it won’t edit anything until you approve the plan. Think twice. Execute once.

I default to plan mode 90% of the time. The latest version lets you provide feedback when rejecting plans, making iteration faster.

When using the Claude API directly, you can enable extended thinking to see Claude’s step-by-step reasoning:

thinking: { type: "enabled", budget_tokens: 5000 }

Claude shows its reasoning in thinking blocks before responding. Useful for debugging complex logic or understanding Claude’s decisions.


Power without control is just chaos. These features let you set boundaries.

"Can I run npm install?" [Allow]
"Can I run npm test?" [Allow]
"Can I cat this file?" [Allow]
"Can I pet that dawg?" [Allow]
×100

/sandbox lets you define boundaries once. Claude works freely inside them.

You get speed with actual security. The latest version supports wildcard syntax like mcp__server__* for allowing entire MCP servers.

Tired of Claude Code asking permission for everything?

Terminal window
claude --dangerously-skip-permissions

This flag says yes to everything. It has “danger” in the name for a reason—use it wisely, ideally in isolated environments or for trusted operations.

Hooks are shell commands that run at predetermined lifecycle events:

  • PreToolUse / PostToolUse: Before and after tool execution
  • PermissionRequest: Automatically approve or deny permission requests
  • Notification: React to Claude’s notifications
  • SubagentStart / SubagentStop: Monitor agent spawning

Configure them via /hooks or in .claude/settings.json.

Use hooks to block dangerous commands, send notifications, log actions, or integrate with external systems. It’s deterministic control over probabilistic AI.


Claude Code works beyond interactive sessions.

You can use Claude Code as a powerful CLI tool for scripts and automation:

Terminal window
claude -p "Fix the lint errors"
claude -p "List all the functions" | grep "async"
git diff | claude -p "Explain these changes"
echo "Review this PR" | claude -p --json

AI in your pipeline. The -p flag runs Claude non-interactively and outputs directly to stdout.

Save any prompt as a reusable command:

Create a markdown file, and it becomes a slash command that can additionally accept arguments:

Terminal window
/daily-standup Run your morning routine prompt
/explain $ARGUMENTS /explain src/auth.ts

Stop repeating yourself. Your best prompts deserve to be reusable.


Claude Code can see and interact with your browser.

Claude can now directly interact with Chrome:

  • Navigate pages
  • Click buttons and fill forms
  • Read console errors
  • Inspect the DOM
  • Take screenshots

“Fix the bug and verify it works” is now one prompt. Install the Chrome extension from claude.ai/chrome.


This is where Claude Code becomes truly powerful.

Santa doesn’t wrap every gift himself. He has elves.

Subagents are Claude’s elves. Each one:

  • Gets its own 200k context window
  • Performs specialized tasks
  • Runs in parallel with others
  • Merges output back to the main agent

Delegate like Santa. Subagents can run in the background while you continue working, and they have full access to MCP tools.

Skills are folders of instructions, scripts, and resources that teach Claude specialized tasks.

They’re packaged once and usable everywhere. And since Agent Skills are now an open standard, they work across any tool that supports them.

Think of skills as giving Claude expertise on demand. Whether that’s your company’s specific deployment process, a testing methodology, or a documentation standard.

Remember when sharing your Claude Code setup meant sending 47 files across 12 directories?

That era is over.

Terminal window
/plugin install my-setup

Plugins bundle commands, agents, skills, hooks, and MCP servers into one package. Discover new workflows via the marketplace, which includes search filtering for easier discovery.

Language Server Protocol (LSP) Integration

Section titled “Language Server Protocol (LSP) Integration”

Language Server Protocol (LSP) support gives Claude IDE-level code intelligence:

LSP integration provides:

  • Instant diagnostics: Claude sees errors and warnings immediately after each edit
  • Code navigation: go to definition, find references, and hover information
  • Language awareness: type information and documentation for code symbols

Claude Code now understands your code the way your IDE does.

The same agent loop, tools, and context management that power Claude Code are now available as an SDK. Build agents that work like Claude Code in as little as 10 lines of code:

import { query } from '@anthropic-ai/claude-agent-sdk';
for await (const msg of query({
prompt: "Generate markdown API docs for all public functions in src/",
options: {
allowedTools: ["Read", "Write", "Glob"],
permissionMode: "acceptEdits"
}
})) {
if (msg.type === 'result') console.log("Docs generated:", msg.result);
}

This is just the beginning.


ShortcutAction
!commandExecute bash immediately
Esc EscRewind conversation/code
Ctrl+RReverse search history
Ctrl+SStash current prompt
Shift+Tab (×2)Toggle plan mode
Alt+P / Option+PSwitch model
Ctrl+OToggle verbose mode
Tab / EnterAccept prompt suggestion
CommandPurpose
/initGenerate CLAUDE.md for your project
/contextView token consumption
/statsView your usage statistics
/usageCheck rate limits
/vimEnable vim mode
/configOpen configuration
/hooksConfigure lifecycle hooks
/sandboxSet permission boundaries
/exportExport conversation to markdown
/resumeResume a past session
/renameName current session
/themeOpen theme picker
/terminal-setupConfigure terminal integration
FlagPurpose
-p "prompt"Headless/print mode
--continueResume last session
--resumePick a session to resume
--resume nameResume session by name
--teleport idResume a web session
--dangerously-skip-permissionsYOLO mode

When I started this advent calendar, I thought I was just sharing tips. But looking back at these 31 days, I see something more: a philosophy of human-AI collaboration.

The best features in Claude Code are about giving you control. Plan mode. Agent Skills. Hooks. Sandbox boundaries. Session management. These are tools for working with AI, not surrendering to it.

The developers who get the most out of Claude Code aren’t the ones who type “do everything for me.” They’re the ones who’ve learned when to use Plan mode, how to structure their prompts, when to invoke ultrathink, and how to set up hooks that catch mistakes before they happen.

AI is a lever. These features help you find the right grip.

Here’s to 2026.


Originally published by Ado Kukic as “Advent of Claude: 31 Days of Claude Code” on adocomplete.com.

Have a favorite Claude Code feature? Let us know on Twitter or open an issue on the Claude Code repository.

Boris Cheny's Claude Code Workflow Revealed: Running 15-20 Opus 4.5 Instances in Parallel

Boris Cheny’s Claude Code Workflow Revealed: Running 15-20 Opus 4.5 Instances in Parallel

Section titled “Boris Cheny’s Claude Code Workflow Revealed: Running 15-20 Opus 4.5 Instances in Parallel”

“I’m Boris and I created Claude Code. Lots of people have asked how I use Claude Code, so I wanted to show off my setup a bit.”

— Boris Cherny, January 2, 2026

When the creator of Claude Code shares his personal workflow, the development community pays attention. Boris Cherny recently revealed his surprisingly “vanilla” yet highly sophisticated approach to maximizing AI-assisted development productivity.

Introduction: Compound Thinking and Verification

Section titled “Introduction: Compound Thinking and Verification”

At the core of Boris’s workflow are two fundamental mindsets:

  1. Compound Thinking - The CLAUDE.md file isn’t a one-time document but a continuously evolving knowledge base accumulated through daily work, code reviews, and problem discovery
  2. Verification Loops - Verification can improve output quality by 2-3x, addressing a core limitation in current AI programming: AI generates code well, but doesn’t inherently know if it actually works or provides good UX

Boris emphasizes: “A good plan is half the success” and invests heavily in upfront planning before switching to auto-accept mode for implementation.

Multi-Instance Parallelism: 15-20 Claude Instances Running Simultaneously

Section titled “Multi-Instance Parallelism: 15-20 Claude Instances Running Simultaneously”

Boris’s workstation runs at least 15 Claude instances concurrently:

EnvironmentInstancesPurpose
Terminal (iTerm2)5 tabsNumbered 1-5, using system notifications for attention management
Browser5-10 tabsclaude.ai/code sessions
TransportBidirectionalUsing & to transfer local sessions to web, --teleport for cross-session movement

This parallel workflow allows Boris to advance multiple tasks simultaneously, effectively orchestrating an intelligence matrix of AI agents.

Model Strategy: Opus 4.5 with Thinking Mode - Exclusively

Section titled “Model Strategy: Opus 4.5 with Thinking Mode - Exclusively”

Boris uses only Opus 4.5 with thinking mode enabled. His rationale is counterintuitive but proven:

“Although Opus is larger and slower, because of its strong understanding and accurate tool usage, it’s actually faster overall. No need for repeated corrections and guidance—it gets it right the first time. That’s true efficiency.”

The upfront cost of larger models pays dividends through reduced iteration cycles and higher-quality first-pass outputs.

Team Knowledge Base: Shared CLAUDE.md in Git

Section titled “Team Knowledge Base: Shared CLAUDE.md in Git”

The Claude Code team maintains a shared CLAUDE.md file committed to Git that every team member updates weekly. The logic is simple:

“Whenever you see Claude do something wrong, write it into CLAUDE.md. Next time Claude will know not to do that.”

This transforms team coding standards and collective experience into AI-accessible knowledge, creating a flywheel where:

  • Each code review improves CLAUDE.md
  • Improved CLAUDE.md automatically raises subsequent code quality
  • Knowledge compounds over time

During code reviews, Boris uses @.claude tags on colleagues’ PRs, instructing Claude to add discovered issues to CLAUDE.md. This is powered by Claude Code’s GitHub Action (installed via /install-github-action).

This is their version of “compound engineering”—every code review systematically improves the knowledge base, which then automatically improves future code quality.

Plan Mode: Discussion Before Implementation

Section titled “Plan Mode: Discussion Before Implementation”

Most sessions start with Plan mode (activated via double Shift+Tab). Boris discusses back and forth with Claude until satisfied with the plan, then switches to auto-accept edit mode where Claude typically completes implementation in one pass.

The pattern reinforces the principle: invest in planning, execute with confidence.

Slash Commands: Automating Inner Loop Workflows

Section titled “Slash Commands: Automating Inner Loop Workflows”

Boris has converted frequently repeated “inner loop” workflows into slash commands stored in .claude/commands/ and committed to Git:

  • Eliminates repetitive prompt engineering
  • Claude itself can invoke these commands
  • Team-wide standardization of workflows
  • Example: /verify command for validation workflows

Key subagents in Boris’s toolkit:

SubagentPurpose
code-simplifierSimplifies code after Claude completes work
verify-appContains detailed instructions for end-to-end Claude Code testing

Subagents essentially automate the most common workflows, ensuring every PR runs through standardized quality gates.

Post-Tool-Use Hook: Automatic Code Formatting

Section titled “Post-Tool-Use Hook: Automatic Code Formatting”

The team uses a Post-Tool-Use hook to auto-format Claude-generated code. Since Claude typically generates well-formatted code, the hook only handles the final ~10%, preventing CI format failures while maintaining code style consistency.

Permissions Management: Pre-Allow Rather Than Skip

Section titled “Permissions Management: Pre-Allow Rather Than Skip”

Boris doesn’t use --dangerously-skip-permissions. Instead, he uses /permissions to pre-allow common, safe bash commands in his environment, avoiding unnecessary permission prompts while maintaining security awareness.

Configuration is stored in .claude/settings.json and shared with the team via Git.

Claude Code integrates with Boris’s entire toolchain:

ToolIntegrationUse Case
SlackMCP serverSearch and post messages
BigQuerybq CLIRun queries for analysis
SentryDirect integrationFetch error logs

The Slack MCP configuration (.mcp.json) is also committed to Git for team sharing.

Long-Running Tasks: Background Agents and Stop Hooks

Section titled “Long-Running Tasks: Background Agents and Stop Hooks”

For extended tasks, Boris employs several strategies:

  1. Background agents for verification upon completion
  2. Agent Stop hooks for more deterministic verification
  3. Ralph-Wiggum plugin (originally conceived by Geoffrey Huntley)
  4. Sandbox mode with --permission-mode=dontAsk or --dangerously-skip-permissions for uninterrupted work

The Most Critical Insight: Give Claude Verification Feedback

Section titled “The Most Critical Insight: Give Claude Verification Feedback”

Boris’s most important insight:

“The most important thing is giving Claude a way to verify its work. With this feedback loop, final result quality improves 2-3x.”

The Claude Code team uses the Claude Chrome extension to test every change. Claude opens the browser, tests the UI, and iterates until code works and user experience is satisfactory.

Verification methods vary by domain—running a bash command, executing test suites, or testing in browser/mobile emulators—but investing in robust verification is universally applicable.

1. Start session in Plan mode (Shift+Tab ×2)
2. Discuss approach with Claude until plan solidifies
3. Switch to auto-accept mode for implementation
4. Use verify subagent for testing
5. Run code-simplifier for cleanup
6. If issues found, add learning to CLAUDE.md
7. Commit and repeat
PracticeBenefit
Start with Plan modeReduces rework by 50%+
Use Opus 4.5 thinkingHigher quality first-pass output
Invest in verification2-3x quality improvement
Maintain shared CLAUDE.mdTeam knowledge compounds
Automate via slash commandsConsistency across sessions
Code review with @.claudeContinuous knowledge improvement
PitfallSolution
Skipping verificationAlways implement verification feedback loops
Not updating CLAUDE.mdTreat every issue as a learning opportunity
Using smaller models to save tokensOpus 4.5 is faster overall due to fewer iterations
Solo knowledge silosCommit CLAUDE.md to Git for team sharing
Ignoring code review learningsUse @.claude to capture insights automatically
AspectBoris’s ApproachTraditional AI Coding
Model selectionOpus 4.5 exclusivelyMix of models for cost savings
PlanningHeavy upfront (Plan mode)Jump straight to coding
Knowledge captureSystematic (CLAUDE.md)Ad-hoc or not captured
VerificationBuilt-in feedback loopsManual testing only
Team scalingShared configs in GitIndividual setups
Parallelism15-20 instances1-2 instances

Boris Cherny’s Claude Code workflow demonstrates that maximum productivity comes from:

  1. Compound thinking - Knowledge accumulates and compounds over time
  2. Verification loops - Quality feedback improves output 2-3x
  3. Opus 4.5 exclusivity - Larger models are faster overall
  4. Parallel execution - 15-20 instances working simultaneously
  5. Shared knowledge bases - Team learning through Git-synced CLAUDE.md

The setup might be “surprisingly vanilla” in configuration, but the methodology represents a sophisticated rethinking of AI-assisted development—transforming from single-shot interactions to a continuously learning, parallel-processing, verification-driven development ecosystem.


“The granularity of productivity has been completely transformed. In the past, we were discussing how to write a good function, while Boris is discussing how to schedule an intelligence matrix composed of 20 Opus 4.5s.”

— 码上盈 | AI陪你做生意

Claude HUD: Real-Time Session Visibility for Claude Code

TL;DR: Claude HUD by jarrodwatts is a Claude Code plugin that displays real-time session information — context usage, tool activity, agent status, and todo progress — right below your input. No separate window, no tmux required, updates every ~300ms.


Have you ever found yourself mid-conversation with Claude Code, wondering:

  • How much context do I have left?
  • Which subagent is stuck on what task?
  • What tools has Claude been using?

Claude HUD answers all these questions at a glance. It’s a heads-up display that shows exactly what’s happening in your Claude Code session, always visible below your input area.


Claude HUD is a plugin that extends Claude Code’s statusline API to provide real-time session visibility. It works by:

  1. Reading Claude Code’s native token data (not estimates)
  2. Parsing the transcript for tool/agent activity
  3. Updating the display every ~300ms

Key Insight: Unlike external monitoring tools, Claude HUD uses Claude Code’s built-in statusline API — meaning it works in any terminal, requires no separate window or tmux setup, and displays accurate data directly from the source.


Inside a Claude Code instance, run:

Terminal window
# Step 1: Add the marketplace
/plugin marketplace add jarrodwatts/claude-hud
# Step 2: Install the plugin
/plugin install claude-hud
# Step 3: Configure the statusline
/claude-hud:setup

Done! The HUD appears immediately — no restart needed.


[Opus 4.5] ████░░░░░░ 19% | 2 CLAUDE.md | 8 rules | 6 MCPs | 6 hooks | ⏱️ 1m
ElementDescription
ModelCurrent model in use (e.g., Opus 4.5, Sonnet 4)
Context barVisual meter with color coding (green → yellow → red)
Config countsNumber of CLAUDE.md files, rules, MCPs, and hooks loaded
DurationHow long the session has been running
✓ TaskOutput ×2 | ✓ mcp_context7 ×1 | ✓ Glob ×1 | ✓ Skill ×1
  • Running tools show a spinner with the target file
  • Completed tools aggregate by type with counts
✓ Explore: Explore home directory structure (5s)
✓ open-source-librarian: Research React hooks patterns (2s)

Shows agent type, current task, and elapsed time.

✓ All todos complete (5/5)
  • Current task or completion status
  • Progress counter (completed/total)

Use CaseHow Claude HUD Helps
Context managementSee your context fill before auto-compaction hits
Agent debuggingKnow exactly which subagent is doing what
Performance monitoringIdentify which tools are being called most frequently
Todo trackingWatch task completion in real-time without asking

Watch the context bar as you work. When it approaches ~80%, consider:

  • Using /compact focus: "current task" to trim unnecessary history
  • Checking which files are consuming the most tokens
  • Asking Claude to summarize long conversations

When using multi-agent workflows, Claude HUD helps you:

  • See which agents are running simultaneously
  • Identify if an agent is stuck (elapsed time keeps growing)
  • Understand the parallel execution flow

Over time, you’ll notice patterns:

  • Which tools you use most frequently
  • Whether certain operations trigger cascading tool calls
  • Opportunities to optimize your workflow

FeatureClaude HUD/contextccstatusline
Real-time updates✓ Every ~300msManual commandEvery ~1s
Agent tracking
Todo progress
Context breakdownBar visualDetailed segmentsBar visual
InstallationPlugin built-inNative commandExternal tool
Terminal requirementAny terminalAny terminaltmux required

Note: These tools complement each other. Use Claude HUD for at-a-glance monitoring and /context for detailed diagnostics.


  • Claude Code v1.0.80+
  • Node.js 18+ or Bun
  • Plugin marketplace access

  1. Verify Claude Code version: claude --version
  2. Run /claude-hud:setup again
  3. Check that the plugin is installed: /plugin list
  • The bar uses Claude Code’s native token data
  • Slight variations from billing are expected
  • Use /context for detailed breakdown
  • This may indicate a stuck agent
  • Consider interrupting and retrying the task
  • Check the agent’s input for potential issues

Claude Code → stdin JSON → claude-hud → stdout → displayed in terminal
↘ transcript JSONL (tools, agents, todos)
  • Token data: Native Claude Code statusline API
  • Tool activity: Parsed from session transcript
  • Agent status: Task tracking metadata
  • Todo progress: TodoWrite tool results

Terminal window
git clone https://github.com/jarrodwatts/claude-hud
cd claude-hud
npm ci && npm run build
npm test

See CONTRIBUTING.md for guidelines.


Since installing Claude HUD:

  • Reduced context anxiety: No more surprise compaction
  • Faster debugging: Can see immediately which agent is stuck
  • Better session management: Know when to wrap up and summarize

Claude HUD is a small plugin with a big impact: it makes the invisible visible. By showing context usage, tool activity, agent status, and todo progress in real-time, it gives you the situational awareness needed to use Claude Code more effectively.

Whether you’re a heavy user of agents, working with large codebases, or just want better visibility into your sessions, Claude HUD is worth installing.

Install it today:

Terminal window
/plugin marketplace add jarrodwatts/claude-hud
/plugin install claude-hud
/claude-hud:setup

Claudian: An Obsidian Plugin That Embeds Claude Code as a Sidebar Chat Interface

TL;DR: Claudian by YishenTu embeds Claude Code as a sidebar chat interface in Obsidian, giving your vault full agentic capabilities — file read/write, bash commands, vision support, MCP servers, and multi-step workflows — all while seamlessly integrating with your notes.


If you’re like me, your Obsidian vault is more than just a note-taking app — it’s your second brain, your project hub, your knowledge base. Now imagine having Claude Code’s full AI agent capabilities integrated directly into that workspace.

That’s exactly what Claudian delivers. It’s an Obsidian plugin that embeds Claude Code as a sidebar chat interface, turning your vault into Claude’s working directory with complete agentic capabilities.

Why this matters: Unlike traditional chatbots or simple AI assistants, Claudian gives Claude actual agency — it can read, write, and edit files in your vault, execute bash commands, use tools, run multi-step workflows, and even connect to external services via MCP. All while staying contextually aware of your notes.


Claudian is an Obsidian plugin built on the Claude Agent SDK that brings Claude Code’s capabilities directly into your Obsidian workspace. Think of it as:

  • A Sidebar Chat: Click the bot icon or use the command palette to open Claude in a sidebar panel
  • Full Agentic Power: Claude can read/write files, run bash commands, and execute multi-step workflows within your vault
  • Context-Aware: Automatically attaches your focused note, lets you @mention files, and includes selected text
  • Vision Support: Analyze images via drag-drop, paste, or file path
  • Extensible: Supports slash commands, custom instructions, skills, and MCP servers

Key Insight: This isn’t just a chat interface — it’s Claude Code running inside Obsidian with your vault as its working directory.


Leverage Claude Code’s complete power within your Obsidian vault:

CapabilityDescription
File OperationsRead, write, and edit files in your vault
Bash CommandsExecute shell commands with approval safety
Multi-step WorkflowsClaude can plan and execute complex tasks
Tool UseFull access to Claude’s tool ecosystem

Claudian makes Claude contextually aware of your work:

  • Auto-attach focused note: The note you’re viewing is automatically included as context
  • @mention files: Type @ to attach other files from your vault
  • Selection awareness: Selected text is automatically included in conversations
  • Image support: Drag-drop, paste, or reference images by path
  • External directories: Configure context paths for read-only access outside your vault
  • Exclude by tag: Prevent sensitive notes from auto-loading

Select text in your editor and use a hotkey to edit it directly with Claude:

  • Word-level diff preview shows exactly what changed
  • Read-only tool access provides context without modifications
  • Apply changes with a single click

Create reusable prompt templates triggered by /command:

  • Argument placeholders (e.g., {topic})
  • @file references for context
  • Optional inline bash substitutions
  • Override model and allowed tools per command

Add custom instructions directly from chat input:

  • Type # to enter instruction mode
  • Refine system prompts on-the-fly
  • Review and edit in a modal before saving

Connect external tools and data sources via Model Context Protocol:

  • Transport types: stdio, SSE, HTTP
  • Context-saving mode: Enable with @server-name
  • @-mention activation: Trigger MCP servers inline
  • Claude Code compatible: Share configs with Claude Code
  • Model selection: Haiku, Sonnet, or Opus
  • Custom models: Configure via environment variables
  • Thinking budget: Fine-tune extended thinking tokens
  • Context gauge: Real-time context window usage display

Toggle read-only exploration before implementation:

  • Press Shift+Tab to enter Plan Mode
  • Claude explores codebase without making changes
  • Presents a plan for your approval
  • Implements after you confirm
  • Permission modes: YOLO (bypass prompts) or Safe (require approval)
  • Safety blocklist: Block dangerous bash commands
  • Vault confinement: File tools limited to your vault with symlink-safe checks
  • Export paths exception: Allow writes to specified directories (e.g., ~/Desktop)

Section titled “Option 1: Install from Release (Recommended)”
  1. Download the latest release from GitHub Releases
  2. Create a folder called claudian in your vault’s plugins folder:
/path/to/vault/.obsidian/plugins/claudian/
  1. Copy main.js, manifest.json, and styles.css into the folder
  2. Enable in Obsidian: Settings → Community plugins → Enable “Claudian”
Terminal window
cd /path/to/vault/.obsidian/plugins
git clone https://github.com/YishenTu/claudian.git
cd claudian
npm install
npm run build

Then enable the plugin in Obsidian settings.


RequirementDetails
Claude Code CLIMust be installed (SDK uses it internally)
ObsidianVersion 1.8.9 or higher
Claude AccessClaude subscription/API or custom provider (OpenRouter, Kimi, GLM, DeepSeek, etc.)
PlatformDesktop only (macOS, Linux, Windows)

Two ways to start chatting:

  1. Click the bot icon in the ribbon
  2. Use the command palette (Cmd/Ctrl + P) and search for “Claudian”
ActionHow
Attach current noteAutomatically included when chat is open
Attach another fileType @ followed by filename
Filter by folderType @folder/ to see files from that directory
Enable MCP serverType @server-name for context-saving MCP
Include selectionSelect text before opening chat
Add imagesDrag-drop, paste, or type file path
  1. Select text in your editor
  2. Use the configured hotkey
  3. Claude edits with diff preview
  4. Apply or discard changes

Type / in the chat input to see available commands. Create new ones in Settings → Slash Commands.

Type # to add custom instructions that modify the system prompt for the current session.


SettingDescription
Command blocklistBlock dangerous bash commands (default: rm -rf, chmod 777, etc.)
Allowed export pathsPaths outside vault for file exports (default: ~/Desktop, ~/Downloads)
Context pathsExternal directories for read-only access
Excluded tagsTags that prevent notes from auto-loading
Media folderWhere vault stores attachments for image embeds
Custom system promptAdditional instructions appended to default prompt
Permission modeYOLO (no prompts) or Safe (approval required)
Environment variablesCustom env vars for Claude SDK (KEY=VALUE format)
MCP ServersAdd/edit/test/delete MCP server configurations

Data is stored in a distributed format (like Claude Code):

vault/.claude/
├── settings.json # User settings and permissions
├── mcp.json # MCP server configurations
├── commands/*.md # Slash commands as Markdown
└── sessions/*.jsonl # Chat sessions (one per conversation)
.obsidian/plugins/claudian/
├── data.json # Machine state (active conversation)
└── .claudian-cache/
└── images/ # Image cache (SHA-256 deduplicated)

src/
├── main.ts # Plugin entry point
├── core/ # Core infrastructure
│ ├── agent/ # Claude Agent SDK wrapper
│ ├── hooks/ # PreToolUse/PostToolUse hooks
│ ├── images/ # Image caching and loading
│ ├── mcp/ # MCP server config management
│ ├── prompts/ # System prompts for agents
│ ├── sdk/ # SDK message transformation
│ ├── security/ # Approval, blocklist, path validation
│ ├── storage/ # Distributed storage system
│ ├── tools/ # Tool constants and utilities
│ └── types/ # Type definitions
├── features/ # Feature modules
│ ├── chat/ # Main chat view
│ ├── inline-edit/ # Inline edit service
│ ├── mcp/ # MCP @-mention detection
│ └── settings/ # Settings tab
├── ui/ # UI components
│ ├── components/ # Input toolbar, dropdowns
│ ├── modals/ # Approval, inline edit, instruction modals
│ ├── renderers/ # Thinking blocks, tool calls, diffs
│ └── settings/ # Env snippets, MCP settings, slash commands
├── utils/ # Utility functions
└── style/ # Modular CSS (→ styles.css)

Claudian implements several security layers:

  1. Vault Restriction: File tools and Bash commands are limited to the vault directory
  2. Path Validation: Uses realpath to prevent symlink escapes
  3. Command Blocklist: Platform-specific dangerous command patterns
  4. Approval System: Safe mode requires approval per tool call
  5. Export Paths: Write operations to external paths are explicit and configurable
  6. Context Paths: Read-only access to external directories
  7. No Telemetry: No additional tracking beyond your configured API provider

The plugin is actively developed with an extensive roadmap:

  • Session persistence within sessions
  • Chat history persistence across restarts
  • Conversation switching with history dropdown
  • File context awareness
  • Extended thinking display
  • Model selection
  • Permission modes (YOLO/Safe)
  • Image support
  • Inline edit feature
  • Slash commands
  • Instruction mode
  • Skills support
  • Context paths
  • Distributed storage
  • Windows support
  • MCP server support
  • Plan mode
  • Auto title generation
  • Hooks and other advanced features

FeatureClaudianCopilotChatGPT Web
File read/write in vault
Bash command execution
Multi-step workflowsLimited
Context awareness✅ (Auto)✅ (Code)
Vision support
Extensible (MCP/Skills)
Custom model support
Works offlinePartial

  1. Install Claude Code CLI if you haven’t already
  2. Install Claudian using one of the methods above
  3. Configure your API key in Claudian settings
  4. Open the chat and try: "Analyze my current note and suggest improvements"
  5. Explore Plan Mode with Shift+Tab for read-only exploration

Claudian represents a significant step forward in AI-assisted knowledge work. By bringing Claude Code’s full agentic capabilities into Obsidian, it transforms your vault from a static note repository into an interactive workspace where Claude can read, write, analyze, and collaborate — all while maintaining deep context awareness of your work.

Whether you’re writing documentation, managing projects, or building a knowledge base, Claudian offers a powerful new way to work with AI that feels natural, integrated, and genuinely useful.

Repository: github.com/YishenTu/claudian

License: MIT


Oh My OpenCode: Claude Code on Steroids - The Ultimate AI Agent Harness

In the rapidly evolving landscape of AI-powered development tools, OpenCode has emerged as a formidable open-source alternative to commercial AI coding assistants. But if you’re a hacker who loves customization and maximum control, Oh My OpenCode is the plugin that transforms OpenCode into something extraordinary.

Created by developer code-yeongyu after spending $24,000 worth of tokens on personal development with various AI tools, Oh My OpenCode represents the distillation of countless hours of testing, configuration, and real-world usage. It’s described by its author as “OpenCode on steroids” — and for good reason.

“If Claude Code does in 7 days what a human does in 3 months, Sisyphus does it in 1 hour. It just works until the task is done. It is a disciplined agent.” — B, Quant Researcher

Oh My OpenCode is a comprehensive plugin for OpenCode that adds:

  • Async Subagents — Run multiple AI agents in parallel, just like Claude Code
  • Curated Agents — Pre-configured specialist agents with optimal models
  • Crafted Tools — LSP and AST grep tools for powerful code manipulation
  • Curated MCPs — Built-in Model Context Protocol servers for extended capabilities
  • Claude Code Compatibility — Full compatibility layer for Claude Code configs

The plugin is battle-tested in production environments and has already helped developers accomplish remarkable feats:

“Knocked out 8000 eslint warnings with Oh My Opencode, just in a day” — Jacob Ferrari

“I converted a 45k line tauri app into a SaaS web app overnight using Ohmyopencode and ralph loop.” — James Hargis

At the heart of Oh My OpenCode is Sisyphus, the default orchestrator agent named after the Greek mythological figure condemned to roll a boulder up a hill for eternity.

“In greek mythology, Sisyphus was condemned to roll a boulder up a hill for eternity as punishment for deceiving the gods. LLM Agents haven’t really done anything wrong, yet they too roll their ‘stones’—their thoughts—every single day. My life is no different. Looking back, we are not so different from these agents.”

Sisyphus comes equipped with a powerful set of tools and teammates:

Teammates (Curated Agents):

  • Oracle (GPT 5.2 Medium) — Design and debugging
  • Frontend UI/UX Engineer (Gemini 3 Pro) — Frontend development
  • Librarian (Claude Sonnet 4.5) — Official docs and codebase exploration
  • Explore (Grok Code) — Fast codebase exploration with contextual grep

Built-in Tools:

  • Full LSP/AstGrep support for decisive refactoring
  • Todo Continuation Enforcer — Forces agents to finish tasks
  • Comment Checker — Prevents excessive AI-generated comments
  • Claude Code Compatibility — Commands, agents, skills, MCPs, and hooks
  • Curated MCPs: Exa (web search), Context7 (official docs), Grep.app (GitHub search)
  • Async agents with background execution
  • Session management and recovery

Oh My OpenCode enables sophisticated workflows where different AI models work in parallel:

While Gemini 3 Pro writes the frontend as a background task,
Claude Opus 4.5 handles the backend. Stuck debugging? Call GPT 5.2 for help.
When the frontend reports done, verify and ship.

Unlike other AI harnesses that limit agent access to code analysis, Oh My OpenCode gives agents full access to:

  • lsp_hover — Type info and documentation
  • lsp_goto_definition — Jump to symbol definitions
  • lsp_find_references — Find all usages across workspace
  • lsp_document_symbols — Get file symbol outline
  • lsp_workspace_symbols — Search symbols by name
  • lsp_diagnostics — Get errors before building
  • lsp_rename — Rename symbols across workspace
  • ast_grep_search — AST-aware code pattern search
  • ast_grep_replace — AST-aware code replacement

Inspired by Anthropic’s Ralph Wiggum plugin, the Ralph Loop is a self-referential development loop that runs until task completion:

Terminal window
/ralph-loop "Build a REST API"

The loop detects <promise>DONE</promise> to know when complete and auto-continues if the agent stops prematurely. It supports all programming languages and can be configured with custom iteration limits.

Oh My OpenCode provides a comprehensive compatibility layer for Claude Code:

  • Hooks Integration — PreToolUse, PostToolUse, UserPromptSubmit, Stop
  • Config Loaders — Commands, Skills, Agents, MCP configs from standard locations
  • Data Storage — Todo management and transcripts in Claude Code format
  • Compatibility Toggles — Fine-grained control over which features to enable

Intelligent context management features:

  • Context Window Monitor — Alerts at 70%+ usage
  • Preemptive Compaction — Compacts session at 85% usage (enabled by default)
  • Anthropic Auto Compact — Automatic summarization at token limits
  • Tool Output Truncator — Prevents one search from eating your entire context
Terminal window
bunx oh-my-opencode install
# or use npx if bunx doesn't work
npx oh-my-opencode install

Follow the prompts to configure your Claude, ChatGPT, and Gemini subscriptions.

Paste this into a fresh OpenCode session:

Install and configure by following the instructions here
https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/refs/heads/master/README.md

The agent will guide you through the entire setup process.

Configuration is stored in JSON/JSONC format:

User config: ~/.config/opencode/oh-my-opencode.json Project config: .opencode/oh-my-opencode.json

{
"$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-opencode/master/assets/oh-my-opencode.schema.json",
"sisyphus_agent": {
"disabled": false,
"default_builder_enabled": false,
"planner_enabled": true,
"replace_plan": true
},
"agents": {
"oracle": {
"model": "openai/gpt-5.2"
},
"frontend-ui-ux-engineer": {
"model": "google/gemini-3-pro-high"
}
},
"disabled_hooks": ["startup-toast"],
"ralph_loop": {
"enabled": true,
"default_max_iterations": 100
}
}

Include these keywords in your prompts to activate specialized modes:

  • ultrawork / ulw — Maximum performance with parallel agent orchestration
  • search / find — Maximized search effort with parallel explore and librarian agents
  • analyze / investigate — Deep analysis mode with multi-phase expert consultation
Ask @oracle to review this design and propose an architecture
Ask @librarian how this is implemented—why does the behavior keep changing?
Ask @explore for the policy on this feature
FeatureClaude CodeOh My OpenCode
Multi-model supportClaude onlyClaude, GPT, Gemini, Grok
Async agentsYesYes
LSP toolsAnalysis onlyFull refactoring
HooksYesYes (compatible)
Custom agentsSkills systemCurated + custom
ExtensibilityLimitedHighly extensible
Open sourceNoYes

If the configuration seems overwhelming, just remember: include the word ultrawork in your prompt. The agent will figure out the rest.

2. Use Background Agents for Parallel Work

Section titled “2. Use Background Agents for Parallel Work”

Let different models work on different parts simultaneously:

Terminal window
# Main agent handles backend
# Spawn Gemini 3 Pro for frontend as background task
# Call GPT 5.2 if debugging gets stuck

Oh My OpenCode aggressively uses multiple agents to lighten context load. Your agent becomes the dev team lead, and you’re the AI manager.

You can disable features you don’t need:

{
"disabled_agents": ["oracle", "frontend-ui-ux-engineer"],
"disabled_hooks": ["comment-checker"],
"disabled_mcps": ["context7"]
}

If you installed Bun via Snap, bunx will fail due to sandboxing. Use npx instead or reinstall Bun via the official installer.

Ensure OpenCode version is 1.0.150 or higher:

Terminal window
opencode --version

For Google Gemini, consider using the external opencode-antigravity-auth plugin for multi-account load balancing.

Q: Do I need all AI subscriptions?

A: No! You can use Oh My OpenCode with just one provider. The plugin supports Claude, ChatGPT, and Gemini, but you pick what you have.

Q: Is this suitable for beginners?

A: The plugin is powerful but can be complex. The author recommends including ultrawork in your prompts — the agent will handle optimization automatically.

Q: How does this compare to AmpCode?

A: Oh My OpenCode is heavily influenced by AmpCode and Claude Code, with features ported and often improved. It’s designed for the open-source OpenCode platform.

Q: Can I use this with existing Claude Code configs?

A: Yes! The Claude Code compatibility layer means your existing configurations, hooks, and skills should work out of the box.

Oh My OpenCode represents the culmination of extensive real-world testing and refinement. It transforms OpenCode from a capable AI coding assistant into a sophisticated multi-agent orchestration platform.

Whether you’re a seasoned developer looking to maximize productivity or an AI enthusiast exploring the boundaries of what’s possible, Oh My OpenCode offers a powerful, extensible, and thoroughly tested solution.

As the author puts it:

“Stop agonizing over agent harness choices. I’ll do the research, borrow from the best, and ship updates here.”

Ready to supercharge your OpenCode experience? Install Oh My OpenCode and let Sisyphus keep that boulder rolling.


Sources:

SivaLabs Marketplace: Supercharge Spring Boot Development with Claude Code

Claude Code has rapidly become a powerful AI-powered development companion, and its extensibility through plugins and MCP servers opens up incredible possibilities for specialized development workflows. Enter SivaLabs Marketplace - a curated collection of plugins designed specifically for Java and Spring Boot developers.

Created by K. Siva Prasad Reddy (sivalabs), a well-known Spring Boot author and educator, this marketplace brings enterprise Java development patterns directly into your AI-assisted coding experience.

SivaLabs Marketplace is a plugin collection for Claude Code that focuses on Spring Boot application development using the Java, Spring Boot, and Spring Data JPA technology stack. It provides specialized skills that automate common development tasks while following established best practices and architectural patterns.

The marketplace is currently in active development (as of January 2026) and includes the spring-boot-dev plugin as its flagship offering.

Getting started with SivaLabs Marketplace is straightforward:

Terminal window
# Add the marketplace to Claude Code
/plugin marketplace add sivaprasadreddy/sivalabs-marketplace
# Enable the marketplace
/plugin enable sivaprasadreddy/sivalabs-marketplace
# Install the Spring Boot development plugin
/plugin install spring-boot-dev@sivalabs-marketplace

After installation, you can verify the plugin and its skills are available using the /plugins command in Claude CLI.

The spring-boot-dev plugin includes five specialized skills that streamline Spring Boot development:

Creates the recommended package structure for Spring Boot projects following best practices. This skill ensures your project starts with a solid architectural foundation.

Automates the creation of JPA entities with proper annotations, relationships, and best practices. Simply describe your entity requirements, and the skill generates production-ready entity classes.

Generates Spring Data JPA repository interfaces for your entities, including custom query methods when needed.

Creates Spring service layer classes with proper dependency injection, transaction management, and business logic separation.

Builds Spring MVC REST API controllers with appropriate annotations, request/response handling, and validation.

Here’s how you can use SivaLabs Marketplace to quickly build a CRUD REST API:

  1. Create a Spring Boot project with Web, Validation, Spring Data JPA, and H2 dependencies
  2. In Claude CLI, prompt: “Implement CRUD REST API for Person with id, name, email and phone fields”
  3. The plugin will automatically generate:
    • JPA Entity (Person.java)
    • Repository interface (PersonRepository.java)
    • Service layer (PersonService.java)
    • REST Controller (PersonController.java)

Each generated component follows Spring Boot best practices and integrates seamlessly with the others.

The marketplace also includes the context7 MCP server, which provides general library documentation lookup capabilities. This enhances Claude Code’s ability to reference official Spring documentation and other libraries during development.

  • New Spring Boot Projects: Quickly scaffold properly structured projects
  • CRUD Operations: Generate standard create, read, update, delete APIs
  • Learning Spring Boot: See best practices in generated code
  • Prototyping: Rapidly build working APIs for testing and validation
  1. Start with Package Structure: Use spring-boot-package-structure-creator first to establish your project layout
  2. Describe Entities Clearly: When using jpa-entity-creator, provide detailed field specifications including types, constraints, and relationships
  3. Review Generated Code: While the plugins follow best practices, always review and adjust generated code to match your specific requirements
  4. Use Context7: Leverage the included MCP server for accessing up-to-date Spring documentation
FeatureSivaLabs MarketplaceGeneric AI CodingManual Development
Spring Boot Best Practices✓ Built-inVariableDepends on developer
Package Structure✓ AutomatedOften missingManual setup
Integration Patterns✓ StandardizedInconsistentManual implementation
Learning CurveLow for Spring devsVariesHigh for beginners
CustomizationGenerated code is editableRequires promptsFull control
  • Early Development: The marketplace is actively developed; features may evolve
  • Spring Boot Specific: Not suitable for non-Spring Java projects
  • Code Review Required: Always review generated code for security, performance, and business logic
  • Claude Code Dependency: Requires Claude Code CLI environment
  • Ensure the marketplace is added and enabled
  • Check your internet connection for marketplace access
  • Verify Claude Code is up to date
  • Provide more specific prompts with detailed requirements
  • Review the Spring Boot version compatibility
  • Check that all required dependencies are in your pom.xml or build.gradle

Given K. Siva Prasad Reddy’s expertise in Spring Boot and his active YouTube channel featuring Spring Boot tutorials, we can expect:

  • Additional skills for testing (JUnit, Mockito, Testcontainers)
  • Security configuration generators
  • Docker and Kubernetes deployment helpers
  • Integration with other Spring ecosystem projects

SivaLabs Marketplace represents an exciting evolution in AI-assisted Spring Boot development. By combining Claude Code’s powerful AI capabilities with specialized Spring Boot knowledge, it helps developers work faster while maintaining code quality and following established patterns.

Whether you’re a seasoned Spring Boot developer looking to accelerate workflow or a learning developer wanting to see best practices in action, SivaLabs Marketplace is a valuable addition to your Claude Code toolkit.


Sources:

Compound Engineering Plugin: Official Claude Code Plugin That Makes Each Unit of Engineering Work Easier

Compound Engineering Plugin: Official Claude Code Plugin That Makes Each Unit of Engineering Work Easier

Section titled “Compound Engineering Plugin: Official Claude Code Plugin That Makes Each Unit of Engineering Work Easier”

“Each unit of engineering work should make subsequent units easier—not harder.”

In traditional software development, every feature added makes the next feature harder to build. More code means more edge cases, more interdependencies, and more complexity. This accumulation of technical debt is the default trajectory for most codebases.

EveryInc’s compound-engineering-plugin for Claude Code inverts this paradigm. It implements a compound engineering methodology where each unit of work makes future work easier through a systematic learning loop.

The compound-engineering-plugin is an official Claude Code plugin developed by EveryInc that orchestrates AI agents to plan, write, review, and compound engineering knowledge. The plugin embodies a revolutionary approach to software development where:

  • 80% of effort goes into planning and review - ensuring thorough understanding before code is written
  • 20% goes into execution - leveraging AI agents for code generation
  • Knowledge compounds over time - each lesson learned feeds back into the system
FeatureDescription
Four-Step WorkflowPlan → Work → Review → Compound → Repeat
Multi-Agent OrchestrationParallel agents handle research, implementation, and review
Knowledge CompoundingLearnings are systematically captured and reused
Worktree ManagementIsolated development environments for each feature
Open SourceMIT licensed, fully auditable and customizable

Prerequisites, Installation and Configuration

Section titled “Prerequisites, Installation and Configuration”
  • Claude Code installed and configured
  • Git for worktree management
  • GitHub CLI (gh) for repository operations

The installation process is straightforward:

Terminal window
# Add the plugin marketplace
/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin
# Install the compound-engineering plugin
/plugin install compound-engineering

Once installed, the plugin provides four main workflow commands:

CommandPurpose
/workflows:planTurn feature ideas into detailed implementation plans
/workflows:workExecute plans with worktrees and task tracking
/workflows:reviewMulti-agent code review before merging
/workflows:compoundDocument learnings to make future work easier

This methodology excels in these scenarios:

  1. Solo Developers Building Products - One developer can achieve what traditionally required a team of five
  2. Complex Feature Development - Multi-component features that require careful planning
  3. Knowledge-Intensive Codebases - Projects where context and patterns matter significantly
  4. Long-Term Projects - Projects where compound effects have time to accumulate

Here’s how a typical compound engineering session flows:

/workflows:plan

The agent:

  • Researches the codebase and commit history
  • Scours the internet for best practices
  • Synthesizes a detailed implementation plan
  • Identifies potential pitfalls and edge cases
/workflows:work

The agent:

  • Creates an isolated worktree
  • Implements according to the plan
  • Writes tests alongside code
  • Tracks task completion
/workflows:review

Multiple agents:

  • Review the code independently
  • Catch issues and suggest improvements
  • Evaluate against established patterns
  • Verify all acceptance criteria
/workflows:compound

The agent:

  • Documents lessons learned
  • Captures new patterns discovered
  • Updates project knowledge base
  • Feeds insights back into the system
  1. Never skip the Plan phase - This is where most value is created
  2. Always Review before merging - Multiple perspectives catch more issues
  3. Document everything - Future agents depend on this knowledge
  4. Trust the process - The compound effect takes time to manifest

⚠️ Learning Curve

The compound engineering approach requires a mindset shift. Traditional developers accustomed to “just coding” may find the emphasis on planning unfamiliar.

⚠️ Initial Investment

The first few cycles will feel slower than traditional development. This is normal - you’re building the knowledge foundation that future cycles will leverage.

⚠️ Tool Requirements

Full benefits require Claude Code with the plugin installed. The methodology is tool-agnostic in theory but optimized for this stack.

Q: Is this only for solo developers?

A: No. While Every uses it to enable solo developers to build complex products, teams can benefit even more from the systematic knowledge capture and multi-agent review process.

Q: Does this work with existing codebases?

A: Yes. The Plan phase includes researching your existing codebase, making it effective for both greenfield and brownfield projects.

Q: Can I use this with other AI coding tools?

A: The plugin is designed for Claude Code, but the compound engineering philosophy is tool-agnostic. Some Every team members also use OpenAI’s Codex CLI.

Q: What happens if the plan is wrong?

A: The Review and Compound phases capture why the plan didn’t work, feeding that learning back into future planning cycles.

IssueSolution
Plugin not foundEnsure marketplace is added before installing
Worktree conflictsClean up existing worktrees with git worktree prune
Agent hallucinationsUse Review phase with multiple agents to catch issues
Slow performanceConsider reducing research scope in Plan phase

Collaboration with Similar Products and Comparative Analysis

Section titled “Collaboration with Similar Products and Comparative Analysis”
Tool/ApproachPlanningExecutionReviewKnowledge Compounding
Compound Engineering Plugin✅ Deep research phase✅ AI-driven✅ Multi-agent✅ Core feature
Traditional Development❌ Ad-hoc✅ Manual✅ Optional❌ Rare
GitHub Copilot❌ None✅ AI-assisted❌ None❌ None
Cursor AI⚠️ Limited✅ AI-driven⚠️ Limited❌ None
Droid (Startup Factory)⚠️ Basic✅ AI-driven⚠️ Basic⚠️ Limited
  1. Knowledge Compounding as First-Class Citizen - Most tools focus on code generation; compound engineering focuses on making future work easier

  2. Multi-Agent Review - Leverages multiple AI perspectives to catch issues that single-agent approaches miss

  3. Systematic Learning Loop - Every lesson is captured and fed back into the system

  4. 80/20 Planning-to-Execution Ratio - Inverts the traditional emphasis on coding speed

The compound engineering plugin can integrate with:

  • CI/CD pipelines - Use Review phase as a gate before deployment
  • Documentation tools - Automatically feed Compound outputs into knowledge bases
  • Project management - Track worktrees as tasks/features
  • Code quality tools - Combine with linters, formatters, and security scanners

EveryInc runs five software products in-house, each primarily built and run by a single person using compound engineering:

“Today, if your AI is used right, a single developer can do the work of five developers a few years ago, based on our experience at Every.”

— Dan Shipper & Kieran Klaassen, Compound Engineering: How Every Codes With Agents

These aren’t demos - they’re products used by thousands of people daily for important work.


Summary: The compound-engineering-plugin represents a paradigm shift in software development. By treating knowledge as a first-class artifact and systematically capturing learnings, it makes each unit of engineering work easier than the last. Whether you’re a solo developer or part of a team, this approach offers a path to sustainable, compounding productivity gains.

Ralph Wiggum: The Official Claude Code Plugin for Autonomous AI Development Loops

Ralph Wiggum: The Official Claude Code Plugin for Autonomous AI Development Loops

Section titled “Ralph Wiggum: The Official Claude Code Plugin for Autonomous AI Development Loops”

Ralph Wiggum Plugin

In the world of AI-assisted development, a fascinating technique has emerged from the mind of Geoffrey Huntley. Named after the famously persistent Ralph Wiggum from The Simpsons, the Ralph Wiggum technique embodies a simple yet powerful philosophy: keep trying until you succeed.

As Huntley famously describes it:

“Ralph is a Bash loop” - a simple while true that repeatedly feeds an AI agent a prompt file, allowing it to iteratively improve its work until completion.

Now, Anthropic has released an official Claude Code plugin that implements this technique, bringing autonomous AI development loops to your fingertips.

The Ralph Wiggum technique is built on the principle of persistent iteration despite setbacks. Instead of trying to get everything right in a single shot, you let the AI fail, learn from its failures, and try again - automatically.

The traditional approach to AI-assisted development looks like this:

Human → Ask AI → AI responds → Human reviews → Human asks again → ...

The Ralph Wiggum approach flips this:

Human → Define task with completion criteria
AI → Work → Try to exit → Block exit → See previous work → Try again
... Loop until completion criteria met

The official ralph-wiggum plugin implements this using a Stop hook that intercepts Claude’s exit attempts:

Terminal window
# You run ONCE:
/ralph-loop "Your task description" --completion-promise "DONE"
# Then Claude Code automatically:
# 1. Works on the task
# 2. Tries to exit
# 3. Stop hook blocks exit
# 4. Stop hook feeds the SAME prompt back
# 5. Repeat until completion

The loop happens inside your current session - no external bash loops needed. The Stop hook in hooks/stop-hook.sh creates the self-referential feedback loop.

  • The prompt never changes between iterations
  • Claude’s previous work persists in files
  • Each iteration sees modified files and git history
  • Claude autonomously improves by reading its own past work

The plugin provides two main commands:

Starting a loop:

Terminal window
/ralph-loop "Build a REST API for todos. Requirements: CRUD operations, input validation, tests. Output <promise>COMPLETE</promise> when done." --completion-promise "COMPLETE" --max-iterations 50

Canceling a loop:

Terminal window
/cancel-ralph
  • --max-iterations <n> - Prevents infinite loops by stopping after N iterations
  • --completion-promise "<text>" - Defines the exact phrase that signals completion

The success of the Ralph Wiggum technique depends heavily on how you write your prompts.

Terminal window
# Too vague - no clear success criteria
"Build a todo API and make it good."
# Too broad - impossible to complete in one go
"Create a complete e-commerce platform."
# No testing/validation specified
"Write code for feature X."
Terminal window
# Clear requirements with completion criteria
Build a REST API for todos.
When complete:
- All CRUD endpoints working
- Input validation in place
- Tests passing (coverage > 80%)
- README with API docs
- Output: <promise>COMPLETE</promise>
# Phased approach for complex tasks
Phase 1: User authentication (JWT, tests)
Phase 2: Product catalog (list/search, tests)
Phase 3: Shopping cart (add/remove, tests)
Output <promise>COMPLETE</promise> when all phases done.
# TDD approach for quality
Implement feature X following TDD:
1. Write failing tests
2. Implement feature
3. Run tests
4. If any fail, debug and fix
5. Refactor if needed
6. Repeat until all green
7. Output: <promise>COMPLETE</promise>
  • Well-defined tasks with clear success criteria
  • Tasks requiring iteration (e.g., getting tests to pass)
  • Greenfield projects where you can walk away
  • Tasks with automatic verification (tests, linters)
  • Tasks requiring human judgment or design decisions
  • One-shot operations
  • Tasks with unclear success criteria
  • Production debugging (use targeted debugging instead)

The Ralph Wiggum technique has demonstrated impressive real-world outcomes:

  • Successfully generated 6 repositories overnight in Y Combinator hackathon testing
  • One $50k contract completed for $297 in API costs
  • Created an entire programming language (“cursed”) over 3 months using this approach

Ralph embodies several key principles that make it effective:

  1. Don’t aim for perfect on first try - Let the loop refine the work
  2. “Deterministically bad” means failures are predictable - Use them to tune prompts
  3. Success depends on writing good prompts - Not just having a good model
  4. Keep trying until success - The loop handles retry logic automatically

The Ralph Wiggum plugin is available in the official Anthropic Claude plugins repository:

Terminal window
# Clone the official plugins repo
git clone https://github.com/anthropics/claude-plugins-official.git
# The plugin is located at:
# plugins/ralph-wiggum/

Key files in the plugin:

  • .claude-plugin - Plugin configuration
  • commands/ - Command definitions (/ralph-loop, /cancel-ralph)
  • hooks/stop-hook.sh - The magic that makes the loop work
  • scripts/ - Supporting scripts

For more complex workflows, the Ralph Orchestrator provides enhanced functionality:

  • Web-based interface for managing multiple Ralph loops
  • Parallel execution of multiple tasks
  • Progress monitoring and logging
  • Integration with CI/CD pipelines

Learn more about Ralph Orchestrator

The Ralph Wiggum plugin represents a paradigm shift in how we think about AI-assisted development. Instead of treating AI as a one-shot tool, it embraces the reality that software development is iterative - and AI should be too.

By letting Claude fail, learn, and try again automatically, we unlock a level of autonomy that wasn’t possible before. Whether you’re building a REST API, generating test suites, or working on a complex multi-phase project, Ralph Wiggum gives you the power to define the destination and let AI find the path.


Published: January 3, 2026 Author: VibeSparking AI Research Team

Practical Review: Building HeartPetBond App with Claude Code + BMAD + GLM-4.7

Core Insight: Can Zhipu GLM-4.7 replace the expensive Opus 4.5 in the Claude Code environment? How does its 200K context window perform within the document-driven BMAD workflow? This post reveals the answers through the real-world development of the HeartPetBond app.

In the AI-assisted programming realm, Claude Opus 4.5 has been the undisputed king, but its high cost (approx. $15/1M input, $75/1M output) deters high-frequency usage. DeepSeek V3, while affordable, occasionally hits bottlenecks with ultra-long contexts (>128K tokens).

I aimed to verify Zhipu GLM-4.7, a strong challenger to DeepSeek V3, by developing the HeartPetBond app to test:

  • Long Context Capability: Can the nominal 200K Tokens Context support an entire project’s documentation and codebase?
  • Output Length: Can the 128K Tokens Output generate complex Flutter pages in one go?
  • Stability & Hallucination: Does logic crumble during continuous development over several days?
  • Cost-Effectiveness: How much money can it save independent developers compared to Opus 4.5?

Context: When using DeepSeek V3 with Claude Code + BMAD, I encountered errors like API Error: 400 ... maximum context length is 131072 tokens... when the context exceeded 128K. GLM-4.7’s 200K context might be the solution.

With over 10 years of Flutter experience and previous success generating the MoneyMind App using Claude Code + BMAD, I set out to see if this new model could handle the challenge.

2. Setup: Integrating GLM-4.7 into Claude Code

Section titled “2. Setup: Integrating GLM-4.7 into Claude Code”

Switching Claude Code’s “brain” is straightforward:

First, we introduce the BMAD (Building Multi-Agent Development) system, the core methodology that makes AI “understand engineering standards.”

Terminal window
bunx bmad-method@alpha install

Claude Code supports connecting external models via MCP or API adapters.

  1. Register and subscribe to the Zhipu BIGMODEL platform to get an API Key.
  2. Configure the default model in Claude Code (or related MCP settings) to point to GLM-4.7.

3. From Idea to Product: The Automated Workflow

Section titled “3. From Idea to Product: The Automated Workflow”

Following the BMAD workflow, HeartPetBond’s birth followed standard Document Driven Development. Here are the key milestones:

Terminal window
> /bmad:bmm:workflows:workflow-init

BMAD scanned the project state and provided a precise analysis:

Terminal window
🎉 Welcome to BMad Method, Vibe Sparking!
📊 Project State Analysis
Status: ACTIVE - You already have workflow tracking!
...
Current Configuration:
Project: vs-heart-pet-bond (Mobile App)
Type: Greenfield (new project)

After confirming brainstorming results, the AI generated the product definition:

Terminal window
> /bmad:bmm:workflows:create-product-brief
Key Findings from Brainstorming Session:
- Product: HeartPetBond - Shared Pet Care Log & Reminders App
- Tech Stack: Flutter + GetX + Drift
- Core Philosophy: 1-second recording, frictionless tracking

It even locked in the tech stack: Flutter for cross-platform UI, GetX for lightweight state management, and Drift for local persistence.

After switching to GLM-4.7, I was most surprised by its “throughput speed” and “depth of understanding.”

In just 2-3 days, GLM-4.7 helped me complete 5 core pages for HeartPetBond (PoC phase):

  • Welcome Page: User onboarding.
  • Ready State: State checks.
  • Home Page: Core recording flow.
  • Settings: Complex configuration management.

The code pass rate was extremely high, rarely missing brackets or breaking logic even in deep Flutter Widget trees.

The cost breakdown is impressive:

  • PoC Phase Total: Approx. 300 Million (300M) tokens.
  • Estimated MVP: For 15 pages and App Store submission, estimated 3 Billion (3B) tokens.

Despite this massive volume, GLM-4.7’s cost is only about 1/7th of Opus 4.5. A Pro subscription (~¥200/month) essentially covers the MVP development needs.

The verdict from this field test is clear: Building mobile apps with GLM-4.7 + Claude Code + BMAD is entirely feasible and highly cost-effective.

  1. High Cost-Performance: GLM-4.7 is a perfect “affordable alternative” to Opus 4.5. It significantly outperforms DeepSeek V3 in daily coding tasks while remaining wallet-friendly.
  2. Long Window Stability: The 200K Context Window is real. It maintained clarity without “catastrophic forgetting” even after loading mass amounts of BMAD documentation.
  3. Engineering Ready: Works seamlessly with Claude Code’s toolchain to handle complex refactoring and debugging.
  1. Reasoning Minor Flaws: In very complex business flow designs, GLM-4.7’s reasoning chain occasionally misses a step compared to the meticulous Opus 4.5. This is manageable via human Code Review and clearer prompts.
  2. Multimodal Gaps: Current API support for multimodal inputs (images/files) is limited, requiring an additional zai-mcp-server configuration.

If you are an independent developer looking for a smart AI pair programmer that won’t break the bank, Claude Code + GLM-4.7 + BMAD is the combination to beat right now.

Life is compounding. Start building your bond today.

pg-aiguide: AI-Optimized PostgreSQL Expertise for Coding Assistants

pg-aiguide: AI-Optimized PostgreSQL Expertise for Coding Assistants

Section titled “pg-aiguide: AI-Optimized PostgreSQL Expertise for Coding Assistants”

In the rapidly evolving landscape of AI-powered development tools, one challenge has persisted: AI coding assistants often generate database code that is outdated, missing critical constraints, unaware of modern PostgreSQL features, and inconsistent with real-world best practices.

Enter pg-aiguide – an innovative MCP server and Claude plugin developed by Timescale (now Tiger Data) that provides AI-optimized PostgreSQL expertise to coding assistants.

pg-aiguide is an open-source tool (Apache-2.0 licensed) that helps AI coding tools write dramatically better PostgreSQL code. It provides three core capabilities:

  1. Semantic Search across the official PostgreSQL manual (version-aware)
  2. AI-Optimized Skills – curated, opinionated Postgres best practices used automatically by AI agents
  3. Extension Ecosystem Docs, starting with TimescaleDB, with more extensions coming soon

AI coding tools frequently generate PostgreSQL code that suffers from several issues:

  • Outdated syntax – not keeping up with modern PostgreSQL versions
  • Missing constraints and indexes – leading to poor data integrity and performance
  • Unaware of modern PG features – missing out on capabilities introduced in recent versions
  • Inconsistent with best practices – not following proven patterns from experienced developers

The pg-aiguide team conducted an impressive comparison test. When asked to create an e-commerce database schema:

  • 4× more constraints compared to AI without pg-aiguide
  • 55% more indexes (including partial and expression indexes)
  • PG17-recommended patterns – using the latest PostgreSQL features
  • Modern features like GENERATED ALWAYS AS IDENTITY and NULLS NOT DISTINCT
  • Cleaner naming & documentation – more maintainable code

pg-aiguide can be used in two ways:

Available at https://mcp.tigerdata.com/docs, it can be configured for any AI coding agent:

{
"mcpServers": {
"pg-aiguide": {
"url": "https://mcp.tigerdata.com/docs"
}
}
}

For Claude Code users, installation is straightforward:

Terminal window
claude plugin marketplace add timescale/pg-aiguide
claude plugin install pg@aiguide

pg-aiguide supports a wide range of AI coding environments:

  • Claude Code – Native plugin support
  • Cursor – One-click install available
  • Gemini CLI – MCP server integration
  • VS Code / VS Code Insiders – Command-line installation
  • Windsurf – Configuration-based setup
  • Codex – MCP server integration

The semantic_search_postgres_docs function performs semantic search over the official PostgreSQL manual, with results scoped to specific Postgres versions. This means AI agents get accurate, version-relevant information.

Through semantic_search_tiger_docs, pg-aiguide searches Tiger Data’s documentation corpus, including TimescaleDB and future ecosystem extensions.

The view_skill function exposes opinionated PostgreSQL best-practice skills covering:

  • Schema design patterns
  • Indexing strategies
  • Data type selection
  • Data integrity and constraints
  • Naming conventions
  • Performance tuning
  • Modern PostgreSQL features

Prompt: “Create a Postgres table schema for storing usernames and unique email addresses.”

pg-aiguide helps generate properly constrained schemas with appropriate indexes and modern PostgreSQL types.

For more complex scenarios, like an IoT device monitoring system:

“Generate a Postgres schema for an IoT device company. Devices collect environmental data including temperature, humidity, pressure, and other measurements. Each device has a unique ID and human-readable name. Analysis includes finding outliers, anomalies, and device-specific ad-hoc analysis.”

pg-aiguide helps design schemas optimized for both recent data analysis and historical reporting.

  • Python (66.5%) – Core server logic
  • TypeScript (23.1%) – Plugin integrations
  • JavaScript (9.3%) – Web interfaces

The project has an ambitious roadmap:

  • pgvector support for vector similarity search
  • PostGIS for geospatial data
  • Community contributions for additional extensions

pg-aiguide welcomes contributions in several areas:

  • New Postgres best-practice skills
  • Additional documentation corpora
  • Search quality improvements
  • Bug reports and feature ideas

pg-aiguide represents a significant step forward in AI-assisted database development. By providing AI agents with deep, versioned PostgreSQL knowledge and proven patterns, it bridges the gap between AI-generated code and production-quality database schemas.

Whether you’re a developer using AI coding assistants or a team building AI-powered development tools, pg-aiguide offers a practical solution to the persistent problem of suboptimal AI-generated database code.


Published: December 31, 2025

ClaudeCode Workflow Studio: Visual Automation Editor for AI Workflows

ClaudeCode Workflow Studio: Visual Automation Editor for AI Workflows

Section titled “ClaudeCode Workflow Studio: Visual Automation Editor for AI Workflows”

Claude Code, Anthropic’s official CLI tool for AI-assisted development, has a powerful automation system through its .claude configuration files. However, creating complex workflows with multiple sub-agents, conditional branching, and user interactions requires editing markdown and YAML files manually. ClaudeCode Workflow Studio (cc-wf-studio) by breaking-brake brings a visual, drag-and-drop editor to VSCode, making workflow creation intuitive and accessible.

ClaudeCode Workflow Studio

ClaudeCode Workflow Studio is a VSCode extension that provides a visual workflow editor for Claude Code. It allows you to:

  • Design workflows visually - Drag and drop nodes onto a canvas
  • Configure without code - Set up sub-agents, skills, and MCP tools through a UI
  • Export with one click - Generate .claude/agents/ and .claude/commands/ files automatically
  • Collaborate with your team - Share workflows via Slack with preview cards

GitHub Repository: breaking-brake/cc-wf-studio VSCode Marketplace: Open VSX License: AGPL-3.0-or-later Version: 3.9.1 (as of December 2025)

The core of cc-wf-studio is its drag-and-drop canvas. Instead of writing markdown and YAML, you visually connect nodes to define workflow logic:

  • Prompt Nodes - Define reusable prompt templates with {{variable}} substitution
  • Sub-Agent Nodes - Configure autonomous AI agents with custom system prompts and tool permissions
  • Skill Nodes - Integrate Claude Code Skills from personal or project directories
  • MCP Nodes - Connect to Model Context Protocol tools for external integrations
  • Control Flow Nodes - IfElse (binary branching), Switch (multi-way branching), AskUserQuestion (user decisions)

One of the standout features is AI-assisted refinement. Instead of generating workflows from scratch once, you can iteratively improve them through conversation:

  1. Click the “Edit with AI” button (✨ sparkle icon)
  2. Describe your changes in natural language (max 2000 characters)
  3. The AI modifies your workflow incrementally, preserving existing work
  4. Repeat until satisfied

This conversational approach builds workflows through multiple rounds of feedback, with the AI maintaining conversation history and applying changes incrementally.

Example prompts:

  • “Add a Sub-Agent node that validates the input data”
  • “Connect the error handler to a logging Sub-Agent”
  • “Change the AskUserQuestion node to have 3 options: High, Medium, Low”

When your workflow is ready, click Export to generate:

  • .claude/agents/*.md - Sub-Agent definitions with system prompts and tool configurations
  • .claude/commands/*.md - SlashCommand definitions that execute the entire workflow

The exported files are ready to use immediately with Claude Code CLI. No manual editing required.

For teams, cc-wf-studio offers Slack integration:

  • Export workflows to Slack channels with preview cards
  • One-click import links for team members
  • Seamless collaboration without leaving your chat workspace
  1. Open VSCode Extensions (Ctrl+Shift+X / Cmd+Shift+X)
  2. Search for “Claude Code Workflow Studio”
  3. Click Install

The extension is also available on Open VSX:

  1. Install the Open VSX extension
  2. Search for “cc-wf-studio”
  3. Click Install
  1. Clone the repository:

    Terminal window
    git clone https://github.com/breaking-brake/cc-wf-studio.git
    cd cc-wf-studio
  2. Install dependencies:

    Terminal window
    npm install
    cd src/webview && npm install && cd ../..
  3. Build the extension:

    Terminal window
    npm run build
  4. Package and install:

    Terminal window
    npx vsce package
  5. Install the generated .vsix file through VSCode’s “Install from VSIX…” option

  • Press Ctrl+Shift+P / Cmd+Shift+P
  • Type “Claude Code Workflow Studio: Open Editor”
  • Press Enter

First-time users get an interactive onboarding tour (available in English, Japanese, Korean, Simplified Chinese, and Traditional Chinese).

The left palette is organized into sections:

  • Basic Nodes: Prompt (templates), Sub-Agent (AI tasks)
  • Control Flow: IfElse (binary branching), Switch (multi-way branching), AskUserQuestion (user decisions)
  • Integration: Skill (Claude Code Skills), MCP (external tools)

Steps:

  1. Drag nodes from the palette onto the canvas
  2. Click a node to edit its properties in the right panel
  3. Connect nodes by dragging from output ports (right) to input ports (left)
  4. Configure node-specific settings (prompts, variables, conditions)
  • Enter a workflow name in the toolbar
  • Click Save to store as JSON in .vscode/workflows/
  • Click Export to generate .claude files

Define reusable prompt templates with template variables:

Hello {{userName}}, your task today is to {{taskType}}.

Variables are automatically detected and validated. At runtime, values are dynamically substituted.

Configure autonomous AI agents with:

  • System Prompt - Custom instructions for the agent
  • Tool Permissions - Choose which tools the agent can access (Read, Write, Bash, etc.)
  • Model Selection - Sonnet (balanced), Opus (complex tasks), Haiku (speed)

Integrate Claude Code Skills into your workflows:

  • Personal Skills - From ~/.claude/skills/ for individual use
  • Project Skills - From .claude/skills/ for team collaboration
  • Create New Skills - Build skills directly from the visual editor with a guided form
  • Browse & Select - Interactive skill browser with descriptions

Integrate Model Context Protocol tools:

  1. Select an MCP server from the dropdown (configured in Claude Code)
  2. Browse available tools or use search to filter
  3. Configure parameters with dynamic form generation based on tool schemas
  4. Real-time validation with error messages

Prerequisites: MCP servers must be configured in Claude Code settings first.

Fixed 2-way branching for binary conditions (True/False, Yes/No, Success/Error).

Variable multi-way branching (2-N branches) with dynamic case management. Ideal for complex routing logic.

  1. Upload Document Prompt - Asks user for file path
  2. PDF Extractor Skill (Personal) - Extracts text from PDF files
  3. Ask User - “Processing type?” → Summarize / Translate / Analyze
  4. Document Processor Skill (Project) - Team-shared processing logic
  5. Format Results Sub-Agent - Creates final output
  1. Code Scanner Sub-Agent - Identifies issues
  2. Ask User - “Priority level?” → Critical Only / All Issues
  3. Filter Results Sub-Agent
  4. Generate Fix Suggestions Sub-Agent
  1. Input URL Prompt - Asks user for target website
  2. Playwright Navigate MCP Tool - Opens browser and navigates to URL
  3. Ask User - “Action type?” → Screenshot / Extract Text / Click Element
  4. Playwright Action MCP Tool - Performs the selected browser action
  5. Process Results Sub-Agent - Analyzes and formats output

The Visual Editor UI and all exported files automatically adapt to your VSCode display language setting (vscode.env.language). Supported languages:

  • English (default)
  • Japanese
  • Korean
  • Simplified Chinese (zh-CN)
  • Traditional Chinese (zh-TW/zh-HK)

This ensures both the editing experience and generated workflows are accessible for international teams.

  • Maximum 50 nodes per workflow
  • AI processing timeout (default 90 seconds, configurable: 30s-5min)
  • Request limited to 2000 characters for AI refinement
  • Conversation history stored only during active session
  • Requires active Claude Code CLI installation

Workflow won’t save

  • Ensure workflow name contains only letters, numbers, hyphens, and underscores
  • Check all required fields are filled
  • Look for error messages in VSCode notifications

Export fails

  • Verify all nodes have valid configurations
  • Ensure node names are unique
  • Check write permissions for .claude directory

Can’t load workflow

  • Click refresh button (↻) to update the list
  • Verify file exists in .vscode/workflows/
  • Check JSON file isn’t corrupted

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-or-later).

Key points:

  • You can use, modify, and distribute the software
  • If you modify and deploy (including as a network service), you must make source code available under AGPL-3.0
  • Commercial use is allowed, but proprietary modifications are not

Copyright (c) 2025 breaking-brake

Built with React Flow • Powered by Claude Code • Inspired by Dify

ClaudeCode Workflow Studio bridges the gap between technical power and accessibility. By bringing visual programming to Claude Code workflows, it:

  1. Lowers the barrier to entry - No need to understand markdown/YAML structure
  2. Accelerates development - Visual feedback reduces trial-and-error
  3. Enables collaboration - Teams can share and review workflows visually
  4. Integrates seamlessly - Exports work directly with Claude Code CLI

As the Claude Code ecosystem continues to evolve, tools like cc-wf-studio demonstrate how community extensions can enhance the core platform’s capabilities.

Ghostty Founder's Vibe Coding: A Conversational Journey with Claude

Ghostty Founder’s Vibe Coding: A Conversational Journey with Claude

Section titled “Ghostty Founder’s Vibe Coding: A Conversational Journey with Claude”

When Mitchell Hashimoto, founder of Ghostty (the modern, GPU-accelerated terminal emulator), wanted to improve the macOS update feature, he didn’t just write code — he had a conversation. In a remarkable session he calls “vibe coding,” Mitchell paired with Claude to iteratively improve the codebase through dialogue, exploration, and shared discovery.

This isn’t about AI replacing developers. It’s about AI as a collaborative partner — and the transcript shows something beautiful: the AI catches things humans miss, the human provides direction and context, and together they build something better than either could alone.

Ghostty Terminal

Vibe coding is a conversational approach to software development where the developer and AI work together through natural dialogue. Rather than treating the AI as a command-execution tool, the developer treats it as a pair programmer — discussing, exploring, and iterating together.

In Mitchell’s session, captured from a real coding conversation on AmpCode, the flow goes like this:

  1. Oracle Consultation — Ask Claude to analyze code for improvements
  2. Discussion — Talk through the findings, make decisions together
  3. Implementation — Write code with Claude’s assistance
  4. Iteration — Learn from failures, adjust approach, try again
  5. Testing — Verify changes work, add tests for confidence

The Session: Improving Ghostty’s Update Feature

Section titled “The Session: Improving Ghostty’s Update Feature”

Mitchell started with a simple request: “Are there any other improvements you can see to be made with the @macos/Sources/Features/ Update feature? Don’t write any code. Consult the oracle.”

The “oracle” — Claude in analysis mode — identified several categories of improvements:

  1. Retain cycle in UpdateDriver.showUpdaterError — The retry closure captured self strongly, creating a memory leak
  2. Threading issues — UI-facing types should be marked @MainActor
  3. Progress value bugs — Progress values needed clamping to [0, 1] to prevent visual glitches
  4. Uncancellable timer — The “No Updates” auto-dismiss task could fire stale updates
  5. Swallowed errorstry? hid potential failures in startUpdater()
  1. ReleaseNotes parsing — Semver detection, git hash handling, edge cases
  2. UpdateState Equatable — Equality tests for downloading/error states
  3. ViewModel formatting — Text/icon/color mappings for each state
  4. Progress math — Division by zero, nil values, overshoot scenarios
  5. Auto-dismiss timing — Verify transitions and task cancellation
  • Add accessibility labels for assistive technologies
  • Clamp/abbreviate long error messages to prevent UI overflow

What makes this session remarkable is the back-and-forth:

Mitchell: “Stop stop stop. Undo all the main actor stuff.”

Claude: “Done! I’ve reverted all the @MainActor changes. The build now succeeds…”

Mitchell: “For the error message, instead of truncating, isn’t there a SwiftUI standard way to do this?”

Claude: “You’re absolutely right! SwiftUI has .lineLimit() and .truncationMode() for this…”

The human provides course correction when the AI goes down a problematic path. The AI suggests better approaches when the human asks questions. They learn from each other.

retry: { [weak self, weak viewModel] in
viewModel?.state = .idle
DispatchQueue.main.async { [weak self] in
guard let self else { return }
// ... rest of code
}
}
let progress = min(1, max(0, Double(download.progress) / Double(expectedLength)))
ProgressView(value: progress)
@State private var resetTask: Task<Void, Never>?
onChange(of: model.state) { newState in
resetTask?.cancel() // Cancel any existing task
if case .notFound = newState {
resetTask = Task { [weak model] in
try? await Task.sleep(for: .seconds(5))
guard !Task.isCancelled, case .notFound? = model?.state else { return }
model?.state = .idle
}
}
}
.accessibilityLabel(model.text)

Simple, but critical — assistive technologies can now announce update status to visually impaired users.

The session added three new test files:

  • UpdateStateTests.swift — 150+ lines testing Equatable conformance for all states
  • UpdateViewModelTests.swift — 300+ lines testing formatting (text, icons, colors)
  • ProgressTests.swift — 150+ lines testing progress math edge cases

The oracle caught a retain cycle and progress value bugs that weren’t obvious. Code review tools often miss these too — having an AI analyze the code with fresh eyes catches different classes of issues.

When the AI suggested marking everything @MainActor, Mitchell recognized this would cause cascading compilation issues and asked to revert. Human judgment about architecture and trade-offs remains essential.

The session goes through multiple attempts:

  • First attempt at @MainActor fails → revert and try different approach
  • Manual error truncation → “isn’t there a SwiftUI standard way?” → use .truncationMode()

Each failure teaches something. The conversation enables rapid iteration.

The oracle suggested comprehensive unit tests. Writing tests alongside fixes ensures the improvements work correctly and prevents regressions.

5. Accessibility Shouldn’t Be an Afterthought

Section titled “5. Accessibility Shouldn’t Be an Afterthought”

The UX improvements weren’t flashy features — they were accessibility labels and proper text truncation. These make the software usable for everyone.

Based on Mitchell’s session, here’s a pattern for vibe coding:

  1. Ask, Don’t Command — “What improvements do you see?” vs “Fix this bug”
  2. Discuss Before Implementing — Talk through the findings, understand the why
  3. Implement Incrementally — Make one change at a time, verify it works
  4. Course Correct — Don’t be afraid to say “stop, undo that”
  5. Add Tests — Build confidence through test coverage
  6. Celebrate Learning — Each failure is a learning opportunity
  • Claude Code — AI pair programmer for the conversation
  • Swift/SwiftUI — Ghostty’s macOS frontend
  • Sparkle — macOS update framework
  • Swift Testing — Modern testing framework

Vibe coding isn’t about AI writing code for you. It’s about having a conversation with code — where the AI brings analytical superpowers, the human brings judgment and context, and together they create something better.

Mitchell’s session shows the future of programming: not humans replaced by AI, but humans augmented by AI — working together, learning from each other, and building better software through conversation.

The improvements to Ghostty’s update feature — safer code, better tests, improved accessibility — are a testament to what’s possible when developers embrace AI as a collaborative partner rather than a mere tool.

Loki Mode: Transform PRDs into Revenue-Generating Products with 37 AI Agents

Loki Mode: Transform PRDs into Revenue-Generating Products with 37 AI Agents

Section titled “Loki Mode: Transform PRDs into Revenue-Generating Products with 37 AI Agents”

“Transform a PRD into a fully deployed, revenue-generating product with zero human intervention.”

What if you could turn a single product requirements document into a complete, deployed startup—without writing a single line of code yourself? Meet Loki Mode, a Claude Code skill that orchestrates 37 specialized AI agents across 6 swarms to autonomously build, deploy, and operate entire businesses.

Loki Mode is a multi-agent autonomous startup system for Claude Code. Just say “Loki Mode” and provide a PRD. The system handles everything:

PRD → Competitive Research → Architecture → Development → Testing → Deployment → Marketing → Revenue

Created by asklokesh, this ambitious project pushes the boundaries of what’s possible with AI agents working in concert.

Loki Mode organizes its AI workforce into specialized swarms, each with a specific domain focus:

  • eng-frontend - Frontend implementation
  • eng-backend - Backend services
  • eng-database - Database architecture
  • eng-mobile - Mobile development
  • eng-api - API design and implementation
  • eng-qa - Quality assurance
  • eng-perf - Performance optimization
  • eng-infra - Infrastructure setup
  • ops-devops - CI/CD pipelines
  • ops-sre - Site reliability engineering
  • ops-security - Security measures
  • ops-monitor - Monitoring systems
  • ops-incident - Incident response
  • ops-release - Release management
  • ops-cost - Cost optimization
  • ops-compliance - Regulatory compliance
  • biz-marketing - Marketing strategy
  • biz-sales - Sales operations
  • biz-finance - Financial management
  • biz-legal - Legal considerations
  • biz-support - Customer support
  • biz-hr - Human resources
  • biz-investor - Investor relations
  • biz-partnerships - Business partnerships
  • Data (3): ML, engineering, analytics
  • Product (3): PM, design, technical writing
  • Growth (4): growth hacking, community, success, lifecycle
  • Review (3): parallel code, business, and security reviewers
CategoryCapabilities
Multi-Agent System37 agents across 6 specialized swarms
Parallel Code Review3 specialized reviewers running simultaneously
Quality Gates14 automated gates including security scans, load tests, accessibility
DeploymentAWS, GCP, Azure, Vercel, Railway with blue-green and canary strategies
Business OpsMarketing, Sales, HR, Legal, Finance, Investor Relations agents
ReliabilityCircuit breakers, dead letter queues, exponential backoff, state recovery
ObservabilityExternal alerting (Slack, PagerDuty), backup/restore, log rotation
Terminal window
cd ~/.claude/skills
# Get latest version
VERSION=$(curl -s https://api.github.com/repos/asklokesh/claudeskill-loki-mode/releases/latest | grep tag_name | cut -d'"' -f4 | tr -d 'v')
# Download and extract
curl -L -o loki-mode.zip "https://github.com/asklokesh/claudeskill-loki-mode/releases/download/v${VERSION}/loki-mode-claude-code-${VERSION}.zip"
unzip loki-mode.zip && rm loki-mode.zip
Terminal window
# For all projects
git clone https://github.com/asklokesh/claudeskill-loki-mode.git ~/.claude/skills/loki-mode
# For a specific project
git clone https://github.com/asklokesh/claudeskill-loki-mode.git .claude/skills/loki-mode
Terminal window
mkdir -p ~/.claude/skills/loki-mode/references
curl -o ~/.claude/skills/loki-mode/SKILL.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/SKILL.md
curl -o ~/.claude/skills/loki-mode/references/agents.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/references/agents.md
curl -o ~/.claude/skills/loki-mode/references/deployment.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/references/deployment.md
curl -o ~/.claude/skills/loki-mode/references/business-ops.md https://raw.githubusercontent.com/asklokesh/claudeskill-loki-mode/main/references/business-ops.md

The autonomous runner handles everything:

Terminal window
# Run with a PRD (fully autonomous with auto-resume)
./autonomy/run.sh ./docs/requirements.md
# Run interactively
./autonomy/run.sh

The runner:

  1. Checks all prerequisites (Claude CLI, Python, Git, etc.)
  2. Verifies skill installation
  3. Initializes the .loki/ directory
  4. Starts a status monitor (updates every 5 seconds)
  5. Starts Claude Code with live output
  6. Auto-resumes on rate limits or interruptions
  7. Continues until completion or max retries
Terminal window
# Launch Claude Code with autonomous permissions
claude --dangerously-skip-permissions
# Then say:
> Loki Mode
# Or with a specific PRD:
> Loki Mode with PRD at ./docs/requirements.md
PhaseDescription
0. BootstrapCreate .loki/ directory structure, initialize state
1. DiscoveryParse PRD, competitive research via web search
2. ArchitectureTech stack selection with self-reflection
3. InfrastructureProvision cloud, CI/CD, monitoring
4. DevelopmentImplement with TDD, parallel code review
5. QA14 quality gates, security audit, load testing
6. DeploymentBlue-green deploy, auto-rollback on errors
7. BusinessMarketing, sales, legal, support setup
8. GrowthContinuous optimization, A/B testing, feedback loops

Every task goes through 3 parallel reviewers:

IMPLEMENT → REVIEW (3 parallel) → AGGREGATE → FIX → RE-REVIEW → COMPLETE
├─ code-reviewer (opus)
├─ business-logic-reviewer (opus)
└─ security-reviewer (opus)
SeverityAction
Critical/High/MediumBlock. Fix immediately. Re-review.
LowAdd // TODO(review): ... comment, continue
CosmeticAdd // FIXME(nitpick): ... comment, continue

When running, Loki Mode creates:

.loki/
├── state/ # Orchestrator and agent states
├── queue/ # Task queue (pending, in-progress, completed, dead-letter)
├── messages/ # Inter-agent communication
├── logs/ # Audit logs
├── config/ # Configuration files
├── prompts/ # Agent role prompts
├── artifacts/ # Releases, reports, backups
└── scripts/ # Helper scripts
.loki/config/circuit-breakers.yaml
defaults:
failureThreshold: 5
cooldownSeconds: 300
.loki/config/alerting.yaml
channels:
slack:
webhook_url: "${SLACK_WEBHOOK_URL}"
severity: [critical, high]
VariableDefaultDescription
LOKI_MAX_RETRIES50Maximum retry attempts
LOKI_BASE_WAIT60Base wait time (seconds)
LOKI_MAX_WAIT3600Maximum wait time (1 hour)
LOKI_SKIP_PREREQSfalseSkip prerequisite checks

Loki Mode includes a comprehensive test suite:

Terminal window
# Run all tests
./tests/run-all-tests.sh
# Individual test suites
./tests/test-bootstrap.sh # Directory structure, state init
./tests/test-task-queue.sh # Queue operations, priorities
./tests/test-circuit-breaker.sh # Failure handling, recovery
./tests/test-agent-timeout.sh # Timeout, stuck process handling
./tests/test-state-recovery.sh # Checkpoints, recovery

The project includes test PRDs in the examples/ directory:

PRDComplexityTimeDescription
simple-todo-app.mdLow~10 minBasic todo app - tests core functionality
api-only.mdLow~10 minREST API only - tests backend agents
static-landing-page.mdLow~5 minHTML/CSS only - tests frontend/marketing
full-stack-demo.mdMedium~30-60 minComplete bookmark manager - full test
FeatureBasic SkillsLoki Mode
Agents137
Swarms-6
Code ReviewManualParallel 3-reviewer
DeploymentNoneMulti-cloud
Business OpsNoneFull stack
State RecoveryNoneCheckpoint/resume
AlertingNoneSlack/PagerDuty

Optionally integrate with Vibe Kanban for visual task monitoring:

Terminal window
npx vibe-kanban
./scripts/export-to-vibe-kanban.sh

Benefits:

  • Visual progress tracking of all 37 agents
  • Manual intervention/prioritization when needed
  • Code review with visual diffs
  • Multi-project dashboard
  • Claude Code with --dangerously-skip-permissions flag
  • Internet access for competitive research and deployment
  • Cloud provider credentials (for deployment phase)
  • Python 3 (for test suite)

Loki Mode is actively developed with recent releases including:

  • Codebase Analysis Mode (v2.7.0)
  • Unified autonomy runner (v2.3.0)
  • Vibe Kanban integration (v2.2.0)
  • Autonomous wrapper with auto-resume (v2.1.0)

Ready to let AI build your next startup?

  1. Install Loki Mode using one of the methods above
  2. Create a PRD describing your product idea
  3. Run ./autonomy/run.sh your-prd.md
  4. Watch as 37 agents collaborate to bring your vision to life

The future of autonomous development is here—and it speaks fluent Claude.


Project Repository: asklokesh/claudeskill-loki-mode

Keywords: claude-code, claude-skills, ai-agents, autonomous-development, multi-agent-system, sdlc-automation, startup-automation, devops, mlops, deployment-automation

Lovcode: Desktop Companion for Claude Code with Chat History & Configuration Management

Lovcode: Desktop Companion for Claude Code

Section titled “Lovcode: Desktop Companion for Claude Code”

Claude Code has revolutionized AI-assisted development, but managing its extensive configuration files, chat history, and custom skills across multiple projects can be challenging. Enter Lovcode — a beautiful desktop companion application that brings all your Claude Code management needs into one unified interface.

Lovcode Desktop Companion

Lovcode is a cross-platform desktop application built as a companion for AI coding tools, with primary focus on Claude Code. It provides a graphical interface to browse chat history, manage configurations, commands, skills, hooks, and more — all without touching the command line.

GitHub Repository: MarkShawn2020/lovcode Author: Mark Shawn (@markshawn2020) License: Apache-2.0 Platforms: macOS • Windows • Linux Latest Version: v0.19.0

Browse and search through all your Claude Code conversations across projects with full-text search capabilities. Quickly find past solutions, code snippets, or discussions without digging through JSON files.

View and manage all your slash commands from ~/.claude/commands/. Edit, create, and organize commands through a clean interface.

Configure and monitor Model Context Protocol (MCP) server integrations visually. Manage connections, settings, and status without editing configuration files.

Manage your reusable skill templates — install, configure, and organize skills from one place.

Configure automation triggers that execute at specific events during your Claude Code sessions.

Manage AI agents with custom models and configurations directly from the UI.

Customize response formatting and display preferences.

Browse and install community-contributed templates and configurations.

LayerTechnology
FrontendReact 19, TypeScript, Tailwind CSS, Vite
BackendRust, Tauri 2
UI Componentsshadcn/ui
State ManagementJotai
SearchTantivy (full-text search)

The combination of Tauri 2 and React provides a lightweight, fast, and native-feeling desktop application with excellent cross-platform support.

Download the latest release for your platform from the GitHub Releases page.

Installers are available for:

  • macOS — .dmg installer
  • Windows — .exe installer
  • Linux — .AppImage, .deb, or .rpm packages

If you prefer to build from source:

Terminal window
# Clone the repository (with submodules)
git clone --recursive https://github.com/markshawn2020/lovcode.git
cd lovcode
# Install dependencies
pnpm install
# Run development mode
pnpm tauri dev
# Build for distribution
pnpm tauri build

On launch, Lovcode scans for Claude Code projects. Select your project to:

  • View chat history with full-text search
  • Browse command usage statistics
  • Access project-specific configurations

The Configuration section provides centralized access to:

  • Commands — View and edit slash commands
  • MCP Servers — Manage server connections
  • Skills — Configure skill templates
  • Hooks — Set up automation triggers
  • Sub-Agents — Manage AI agent configurations
  • Output Styles — Customize response formatting

Version 0.18.0 introduced command trend charts, showing your usage patterns over time. Track which commands you use most and identify opportunities for optimization.

The diagnostics view provides file statistics and system health information, helping you troubleshoot configuration issues.

Lovcode is actively maintained with frequent updates:

  • v0.19.0 (Dec 29, 2025) — Logo generation and management panel, optimized tab group display in collapsed state
  • v0.18.2 (Dec 28, 2025) — Fixed command statistics data inflation in weekly mode
  • v0.18.0 (Dec 28, 2025) — Added command trend charts
  • v0.17.0 (Dec 28, 2025) — Embedded Claude Code and Codex documentation as submodules
  • v0.16.0 (Dec 27, 2025) — StatuslineView editor and marketplace support
  • v0.15.0 (Dec 27, 2025) — LLM provider analytics
  • Centralized Management — No more digging through ~/.claude directories
  • Visual Configuration — GUI-based setup for all Claude Code features
  • Quick Access — Find past conversations and solutions instantly
  • Better Organization — Keep skills, commands, and hooks organized
  • Consistency — Share configurations and templates across team members
  • Onboarding — Help new developers understand available tools
  • Documentation — Built-in documentation for Claude Code and Codex
  • Standards — Enforce consistent command and skill usage
FeatureLovcodeCLI-onlyWeb Dashboards
Chat History Search✓ Full-textManual grepLimited
Visual Config Editor✓ NativeText editorsWeb forms
Offline Capability✓ Yes✓ Yes✗ No
Native Performance✓ Yes✓ Yes✗ No
Cross-Platform✓ Yes✓ Yes✓ Yes

Lovcode is open source under the Apache-2.0 license. Contributions are welcome!

  • Star the project on GitHub: MarkShawn2020/lovcode
  • Report Issues via GitHub Issues
  • Submit Pull Requests for features and fixes

Lovcode fills an important gap in the Claude Code ecosystem by providing a polished desktop interface for managing all aspects of your AI coding assistant. Whether you’re a solo developer looking to organize your configurations or part of a team establishing standards, Lovcode offers the tools you need in a beautiful, performant package.

Download it today from GitHub Releases and take control of your Claude Code workflow.


Links:

Claude Code Transcripts: Publish Your AI Coding Sessions as HTML

Claude Code Transcripts: Publish Your AI Coding Sessions as HTML

Section titled “Claude Code Transcripts: Publish Your AI Coding Sessions as HTML”

When using Claude Code for software development, every session contains valuable insights — debugging approaches, architectural decisions, and problem-solving techniques. But these conversations are locked away in JSON files buried in ~/.claude/projects.

Simon Willison has released claude-code-transcripts, a Python CLI tool that converts these session files into beautiful, browsable HTML transcripts that can be shared with others.

Claude Code Transcripts

claude-code-transcripts is a command-line tool that converts Claude Code session data (stored as JSON or JSONL files) into paginated, mobile-friendly HTML transcripts. It provides:

  • Better readability than the raw Claude Code interface
  • Shareable output that works with any static hosting or GitHub Gists
  • Multiple input sources: local sessions, web sessions via API, or direct JSON files
  • Clean, organized layout with pagination for long sessions

GitHub Repository: simonw/claude-code-transcripts Author: Simon Willison License: Apache 2.0 PyPI: claude-code-transcripts

The tool can be installed using uv (recommended) or run directly without installation:

Terminal window
# Install using uv
uv tool install claude-code-transcripts
# Or run without installation
uvx claude-code-transcripts --help

The tool provides four commands for different use cases:

1. local (default) - Browse Local Sessions

Section titled “1. local (default) - Browse Local Sessions”

Convert sessions stored locally in ~/.claude/projects:

Terminal window
# Interactive picker for recent sessions
claude-code-transcripts
# Explicit local command
claude-code-transcripts local
# Show more sessions in the picker
claude-code-transcripts local --limit 20

Fetch sessions directly from the Claude web API:

Terminal window
# Interactive session picker
claude-code-transcripts web
# Import specific session by ID
claude-code-transcripts web SESSION_ID

On macOS, credentials are automatically retrieved from your keychain. On other platforms, use --token and --org-uuid.

Convert a JSON or JSONL session file directly:

Terminal window
claude-code-transcripts json session.json -o output-directory/
claude-code-transcripts json session.jsonl --open

Convert all local sessions into a browsable HTML archive:

Terminal window
claude-code-transcripts all

This creates a directory structure with:

  • A master index listing all projects
  • Per-project pages listing sessions
  • Individual session transcripts

All commands support these useful options:

OptionDescription
-o, --output DIROutput directory (default: temp dir + open browser)
-a, --output-autoAuto-name subdirectory based on session ID
--repo OWNER/NAMEGitHub repo for commit links
--openOpen generated HTML in default browser
--gistUpload to GitHub Gist and return preview URL
--jsonInclude original session file in output

One of the most powerful features is the --gist option:

Terminal window
# Publish transcript as a Gist
claude-code-transcripts --gist
# Import from web and publish
claude-code-transcripts web SESSION_ID --gist
# Convert specific file and publish
claude-code-transcripts json session.json --gist

This requires the GitHub CLI to be installed and authenticated. The output includes:

Gist: https://gist.github.com/username/abc123def456
Preview: https://gistpreview.github.io/?abc123def456/index.html
Files: /var/folders/.../session-id

The tool generates:

  • index.html - Timeline page with prompts and commits
  • page-001.html, page-002.html, etc. - Paginated transcript pages

See an example transcript created by Simon.

  1. Documentation - Turn complex debugging sessions into reference documentation
  2. Knowledge Sharing - Share architectural decisions with your team
  3. Tutorials - Create step-by-step guides from real coding sessions
  4. Archiving - Build a searchable archive of your development work
  5. Blogging - Transform interesting sessions into blog posts
  • Input Sources: Local ~/.claude/projects, Claude Web API, or JSON/JSONL files
  • Output Format: Static HTML with CSS, no build step required
  • Dependencies: Python 3.8+, minimal dependencies
  • Platform Support: macOS, Linux, Windows
Featureclaude-code-transcriptsclaude-notes
GitHub Gist integration✅ Built-in❌ No
Web API support✅ Yes❌ Local only
Archive all sessions✅ Yes❌ Per-file only
Mobile-friendly✅ Yes✅ Yes
Pagination✅ Yes✅ Yes

Both tools serve similar purposes, but claude-code-transcripts offers more advanced features for sharing and publishing.

claude-code-transcripts fills an important gap in the Claude Code ecosystem by making sessions shareable and readable outside the Claude Code interface. Whether you’re documenting your work, sharing with colleagues, or building a knowledge base, this tool transforms ephemeral AI conversations into permanent, valuable resources.

Links:

Happy Claude Skills: Practical Plugin Collection for Claude Code

Happy Claude Skills: Practical Plugin Collection for Claude Code

Section titled “Happy Claude Skills: Practical Plugin Collection for Claude Code”

Claude Code’s plugin system allows developers to extend its capabilities with custom skills. While the official marketplace is growing, the community has already started creating useful plugins. One such contribution is happy-claude-skills by iamzhihuix, a collection of three practical skills for common productivity tasks.

Happy Claude Skills

happy-claude-skills is an open-source collection of skill plugins designed for Claude Code. It currently includes three skills:

  1. docx-format-replicator - Extract and replicate Word document formatting
  2. video-processor - Download and process videos from YouTube and other platforms
  3. wechat-article-writer - Automated WeChat article writing workflow

GitHub Repository: iamzhihuix/happy-claude-skills Author: iamzhihuix License: MIT

Section titled “Method 1: Plugin Marketplace (Recommended)”

Add the repository as a plugin marketplace in Claude Code:

Terminal window
/plugin marketplace add iamzhihuix/happy-claude-skills

Then install individual skills:

Terminal window
/plugin install docx-format-replicator@happy-claude-skills
/plugin install video-processor@happy-claude-skills
/plugin install wechat-article-writer@happy-claude-skills

Clone and use directly:

Terminal window
git clone https://github.com/iamzhihuix/happy-claude-skills.git
claude --plugin-dir /path/to/happy-claude-skills

Extract formatting from existing Word documents and generate new documents with the same format.

  • Corporate document template replication - Maintain consistent branding across documents
  • Batch document generation - Create multiple documents with identical formatting
  • Technical specification series - Generate spec documents from templates
  • Standardized documentation - Development task sheets, reports, etc.
Terminal window
pip install python-docx

After installation, simply describe your needs in Claude Code:

“I have a document template and need to generate 5 new documents with the same format”

Claude will automatically identify and invoke the appropriate skill.

Download and process videos from YouTube and other platforms. Supports video download, audio extraction, format conversion, and Whisper transcription.

  • Download videos from YouTube and other platforms
  • Extract audio from video files
  • Convert videos to MP4/WebM formats
  • Transcribe audio/video to text using Whisper
Terminal window
# Python packages
pip install yt-dlp openai-whisper
# FFmpeg (macOS)
brew install ffmpeg

“Download this YouTube video and transcribe it to text”

“Extract the audio from this video file”

Automated WeChat article writing workflow with 4 steps: research, writing, title generation, and formatting optimization.

  • Write WeChat official account articles
  • Generate viral headlines
  • Content creation for self-media
  • Article formatting and optimization

The skill follows a 4-step process:

  1. Research - Gather information on the topic
  2. Writing - Generate article content
  3. Title Generation - Create engaging headlines
  4. Formatting - Optimize for WeChat’s editor

“Help me write a WeChat article about AI programming tips”

happy-claude-skills/
├── .claude-plugin/
│ └── marketplace.json # Marketplace configuration
├── skills/
│ ├── docx-format-replicator/
│ │ ├── SKILL.md # Skill definition
│ │ ├── scripts/ # Python scripts
│ │ ├── assets/ # Example files
│ │ └── references/ # Reference docs
│ ├── video-processor/
│ │ ├── SKILL.md # Skill definition
│ │ └── scripts/ # Python scripts
│ └── wechat-article-writer/
│ └── SKILL.md # Skill definition
├── README.md
└── LICENSE

The video-processor skill is adapted from claude-code-hooks-multi-agent-observability by disler.

Claude Code’s plugin system enables community contributions that extend the tool’s capabilities beyond its core features. The happy-claude-skills collection demonstrates practical applications:

  1. Document automation - Reduces manual formatting work
  2. Media processing - Brings video handling capabilities into the coding workflow
  3. Content creation - Streamlines article writing for Chinese audiences

As the Claude Code ecosystem grows, we can expect more community plugins to emerge, further enhancing the tool’s versatility.

The project is open to contributions. If you have ideas for new skills or improvements:

  1. Fork the repository
  2. Create your skill following the existing structure
  3. Submit a pull request

Links:

Quotio: Stop Juggling AI Accounts - A macOS Menu Bar App That Unifies Claude, Gemini, OpenAI, Qwen, and Antigravity

Stop juggling AI accounts. Quotio is a beautiful native macOS menu bar app that unifies your Claude, Gemini, OpenAI, Qwen, and Antigravity subscriptions – with real-time quota tracking and smart auto-failover for AI coding tools like Claude Code, OpenCode, and Droid.

Introduction: The AI Account Management Problem

Section titled “Introduction: The AI Account Management Problem”

As developers, we increasingly rely on multiple AI coding assistants in our daily work. You might use Claude Code for intelligent code completion, GitHub Copilot for inline suggestions, Cursor for AI-powered IDE features, and various OpenAI-based tools for different tasks. Each service comes with its own:

  • Subscription and billing
  • API keys and authentication
  • Usage quotas and rate limits
  • Separate dashboard and management interface

This fragmentation creates constant overhead. You’re juggling multiple browser tabs, switching between different CLI configurations, and inevitably hitting rate limits on one service while another sits idle. Enter Quotio – a unified solution that brings all your AI subscriptions under one roof.

Quotio is a native macOS application that provides unified quota monitoring and request routing for multiple AI provider services. Created by developer Trong Nguyen (nguyenphutrong), Quotio serves two complementary purposes:

  1. Visual Dashboard – Track all your AI API usage limits in one beautiful interface
  2. Optional Local Proxy – Route requests across multiple provider accounts with intelligent load balancing and failover

Quotio offers two operation modes to suit different needs:

A lightweight mode perfect for users who simply want visibility into their AI usage:

  • Real-time quota tracking by reading authentication files from installed CLI tools
  • Support for Claude Code, Codex CLI, Gemini CLI, GitHub Copilot, Cursor, and Antigravity
  • macOS menu bar integration for at-a-glance quota status
  • System notifications for low quota warnings
  • No proxy server required – minimal resource footprint

All Quota-Only features plus powerful proxy capabilities:

  • Local proxy server for request routing and load balancing
  • OAuth-based provider authentication
  • Automatic failover between accounts when quotas are exhausted
  • API key management for secure proxy access
  • Comprehensive usage statistics and request logging
  • Automatic configuration of CLI agents to use the proxy

Quotio unifies 10 AI providers in a single interface:

ProviderQuota-Only ModeFull Mode
Claude
Gemini
OpenAI
Qwen
Antigravity
GitHub Copilot
Cursor
Codex CLI

The menu bar integration provides at-a-glance quota status:

  • Provider symbol (1-2 letters) + lowest percentage across models
  • Example: "G:95% C:42% CP:88%" (Gemini 95%, Claude 42%, Copilot 88%)
  • Color-coded indicators: green (>50%), orange (20-50%), red (<20%)
  • Customizable display options – show/hide providers, change color modes

In Full Mode, Quotio acts as an intelligent proxy:

┌─────────────────┐
│ Coding Tool │
│ (Claude Code) │
└────────┬────────┘
┌─────────────────┐
│ Quotio Proxy │
│ (localhost) │
└────────┬────────┘
┌─────┬─────┬─────┬─────┐
│ Claude│Gemini│OpenAI│Qwen│
│ Acct 1│Acct 1│Acct 1│Acct 1│
└─────┴─────┴─────┴─────┘
(Auto-failover when quota exhausted)

When one account hits its quota limit, Quotio automatically routes requests to another available account, ensuring uninterrupted workflow.

The persistent macOS menu bar presence keeps you informed without interrupting your workflow:

  • Always-visible quota status
  • Quick access to detailed dashboard
  • Low quota notifications
  • Language support: English and Vietnamese
  • macOS 14.6 or later
  • Accounts with supported AI providers (Claude, Gemini, OpenAI, etc.)
  1. Download Quotio from the GitHub Releases page
  2. Launch the app and complete the onboarding flow
  3. Choose your mode: Quota-Only (lightweight) or Full (with proxy)
  4. Connect your accounts via OAuth or manual authentication
  5. Configure your coding tools to use the Quotio proxy (Full Mode)

For AI coding tools, Quotio provides automatic configuration:

Terminal window
# Quotio can auto-configure these tools:
- Claude Code
- OpenCode
- Droid
- Cursor

Scenario: You’re a developer using Claude Code for daily work, but you also have access to Gemini and OpenAI APIs for side projects.

Solution: Quotio lets you see all your quotas at a glance and automatically routes requests when one provider is exhausted.

Scenario: Your team has multiple AI subscriptions across different providers, and team members frequently hit rate limits during peak hours.

Solution: Configure Quotio with multiple accounts per provider for intelligent load distribution and automatic failover.

Scenario: You want to maximize usage of your AI subscriptions before upgrading to higher tiers.

Solution: Use Quotio’s detailed usage statistics to understand consumption patterns and make informed decisions about subscription upgrades.

Built with modern macOS development practices:

  • Framework: SwiftUI with AppKit integration
  • Architecture: MVVM with Actor Model for thread-safe services
  • Concurrency: Swift Concurrency (async/await, actors)
  • Localization: English and Vietnamese support
  • Auto-Updates: Sparkle framework for seamless updates

The project structure follows clean architecture principles:

Quotio/
├── Models/ # Core data structures
├── ViewModels/ # @Observable state managers
├── Views/ # SwiftUI screens and components
├── Services/ # Quota fetchers, proxy manager, API clients
└── Managers/ # Singletons for app-wide coordination
FeatureQuotioManual ManagementOther Solutions
Multi-Provider Support✅ 10+ providers❌ One at a time⚠️ Limited
Real-Time Quota Tracking✅ Menu bar + dashboard❌ Browser tabs only⚠️ Often delayed
Auto-Failover✅ Intelligent routing❌ Manual switching⚠️ Basic routing
Native macOS App✅ Menu bar integration❌ Web-based⚠️ Electron bloat
Open Source✅ Fully open sourceN/A❌ Often proprietary
Offline Capable✅ Works without internet❌ Requires internet⚠️ Limited

As of version 0.2.2, Quotio is actively developed with recent additions including:

  • Quota-Only Mode for lightweight usage
  • Cursor support
  • Enhanced proxy management
  • Internationalization support

Check the CHANGELOG.md for the latest updates.

Quotio solves a real pain point for developers who use multiple AI services. By providing unified quota monitoring, intelligent request routing, and seamless failover, it transforms the fragmented experience of managing multiple AI subscriptions into a cohesive, productive workflow.

Whether you’re an individual developer juggling personal AI subscriptions or part of a team with multiple provider accounts, Quotio offers the tools you need to maximize your AI productivity.

Download Quotio today: github.com/nguyenphutrong/quotio


WeChat Article Writer: Automate WeChat Public Account Content with Claude Code

WeChat Article Writer: Automate WeChat Public Account Content with Claude Code

Section titled “WeChat Article Writer: Automate WeChat Public Account Content with Claude Code”

Creating engaging content for WeChat public accounts (公众号) is a time-consuming process that involves research, writing, headline optimization, and formatting. The wechat-article-writer skill for Claude Code automates this entire workflow, allowing content creators to produce professional articles in minutes rather than hours.

WeChat Article Writer

wechat-article-writer is a Claude Code skill from the happy-claude-skills collection that automates the entire WeChat public account article creation process. It handles:

  • Research - Multi-source web search for latest information
  • Writing - AI-powered content generation with storytelling elements
  • Headlines - Viral title generation with proven formulas
  • Formatting - Professional layout optimized for mobile reading

GitHub Repository: iamzhihuix/happy-claude-skills License: MIT

The skill automatically searches multiple sources in parallel:

  • Official documentation
  • Social media (X/Twitter, Reddit)
  • Technical forums and communities
  • Latest monthly/quarterly content

It uses Claude Code’s built-in WebSearch tool and can spawn parallel tasks to accelerate information gathering.

Content generation follows best practices for WeChat articles:

  • Length: 1000-1500 words (optimal for mobile reading)
  • Opening: Story-driven with emotional hooks (excitement/anxiety/curiosity)
  • Structure: Effect showcase → Problem description → Tutorial → Conclusion
  • Style: Reads your CLAUDE.md to match your personal writing style

Generates 5 viral headlines using proven techniques:

  • Pain points: “Still doing X manually?”
  • Numbers: “3 minutes”, “5 tips” - specific digits are persuasive
  • Results: “Efficiency up 10x”
  • Emotion: “Amazing”, “Secret weapon”, “Ultimate guide”
  • Curiosity: Headlines that make readers want to click

Mobile-optimized layout recommendations:

  • Short paragraphs (3-5 lines each)
  • Key data points in bold, standalone paragraphs
  • Strategic image placement (cover, step illustrations, conclusion)
  • Code blocks with proper spacing and syntax highlighting
  • “Golden quotes” - memorable phrases set apart for impact
  • Claude Code installed
  • Access to Claude Skills feature
Terminal window
# Add the happy-claude-skills marketplace
/plugin marketplace add iamzhihuix/happy-claude-skills
# Install the wechat-article-writer skill
/plugin install wechat-article-writer@happy-claude-skills

Once installed, simply describe your article needs:

Help me write a WeChat article about AI programming tips

Claude Code will automatically:

  1. Detect the request matches the wechat-article-writer skill
  2. Search for latest AI programming trends and tips
  3. Read your CLAUDE.md to match your writing style
  4. Generate a 1200-word tutorial article
  5. Provide 5 viral headline options
  6. Suggest formatting and image placement

Input:

Write a WeChat article about the new Claude Code features

Output:

  1. Research Summary: Latest Claude Code updates from official docs, Twitter discussions, and community forums
  2. Article: 1200-word tutorial with story-driven opening
  3. 5 Headlines:
    • “Still manually copying code? This Claude feature will change your life”
    • “3 minutes to master Claude Code’s hidden superpower”
    • “Productivity up 10x: The Claude Code feature pros don’t talk about”
    • “Amazing! Claude Code can now do this automatically”
    • “The ultimate Claude Code workflow nobody knows about”
  4. Layout Guide: Image placement suggestions, formatting recommendations

The skill searches across multiple platforms in parallel, ensuring your content is well-researched and up-to-date.

By reading your CLAUDE.md file, the skill adapts to your established voice and tone, maintaining consistency across your content.

Headline generation uses data-backed formulas from successful WeChat articles, maximizing click-through rates.

Layout recommendations are specifically designed for WeChat’s mobile interface, where most readers consume content.

  • Tech Bloggers: Quick turnaround on trending topics
  • Marketing Teams: Consistent brand voice across all content
  • Individual Creators: Scale content production without sacrificing quality
  • News Aggregators: Curate and synthesize information efficiently
happy-claude-skills/
└── skills/
└── wechat-article-writer/
├── SKILL.md # Main skill definition
├── skill.config.json # Configuration
└── README.md # Documentation

The happy-claude-skills project is open source. Contributions are welcome:

  1. Fork the repository
  2. Create a feature branch
  3. Submit a pull request

Repository: https://github.com/iamzhihuix/happy-claude-skills

Featurewechat-article-writerManual WritingOther AI Tools
Research automation✓ Multi-source✗ Manual✗ Limited
WeChat optimization✓ Native✓ Manual✗ Generic
Style adaptation✓ CLAUDE.mdN/A✗ Fixed
Headline formulas✓ 5 viral options✗ Manual✗ Basic
Integration✓ Claude Code nativeN/A✗ Copy/paste
  • Requires Claude Code and access to Claude Skills
  • Chinese-language optimized (WeChat specific)
  • Output quality depends on search result availability
  • Requires manual review and editing for best results

Potential improvements being considered:

  • Direct publishing to WeChat API
  • Multi-language support beyond Chinese
  • Image generation integration
  • Analytics tracking integration

The wechat-article-writer skill transforms WeChat content creation from a multi-hour process into a streamlined workflow. By combining research, writing, headline optimization, and formatting into a single automated flow, it helps creators maintain consistency and quality while scaling production.

For Claude Code users who manage WeChat public accounts or create content in Chinese, this skill is a valuable addition to the toolkit.

Claude Code Board: Use Claude Code on Kanban WebUI

Claude Code Board is a web-based Kanban-style management interface designed specifically for the Claude Code CLI. If you are a power user of Claude Code, you might find yourself juggling multiple terminal windows to handle different tasks concurrently. Claude Code Board solves this by providing a unified, visual interface to manage these sessions.

It aims to enhance the developer experience by allowing concurrent management of multiple AI coding sessions with real-time status tracking (idle, processing, completed, error).

Run multiple Claude Code instances simultaneously. The Kanban board allows you to see the status of each session at a glance—whether it’s idle, processing, or completed.

  • Agent Integration: Load custom Claude agents directly from your ~/.claude/agents/ directory.
  • Workflow Stages: Utilize pre-configured stages like Code Review, Bug Fixing, and Feature Development to structure your work.
  • Smart Prompting: Automatically inject agent instructions and custom templates to streamline your interaction with the AI.

Group your sessions under “Work Items,” tag them by project or topic, and automatically manage workspace paths. This keeps your work organized conceptually, not just by terminal ID.

  • WebSocket-powered chat: Real-time updates and interaction.
  • Notifications: Windows Toast notifications alert you when a task is completed.
  • Message Filtering: Filter out “thinking” blocks or tool use logs to focus on the conversation and results.
  • Session Recovery: Resume previous conversations with full context preservation.
  • Operating System: Windows 10/11
  • Runtime: Node.js (v18+)
  • Core Tool: Claude Code CLI installed globally (npm install -g @anthropic-ai/claude-code)
  1. Clone the Repository

    Terminal window
    git clone https://github.com/cablate/Claude-Code-Board.git
    cd Claude-Code-Board
  2. Install Dependencies You need to install dependencies for the root, backend, and frontend.

    Terminal window
    npm install
    cd backend && npm install
    cd ../frontend && npm install
  3. Start the Application

    • Option 1 (Windows): Simply run start.bat.
    • Option 2 (Manual): Run npm run dev:backend and npm run dev:frontend in separate terminals.
  4. Access: Open your browser and navigate to http://localhost:5173.

Imagine you are working on a feature, but you also need to fix a critical bug and review a PR. Instead of opening three terminals and losing track of context, you can create three cards on the Claude Code Board: “Feature X”, “Bug Y”, and “PR Review Z”. You can switch between them easily and see their progress.

You can configure specialized agents (e.g., an “Architect” agent or a “Debugger” agent) by creating .md files in your agents directory. When starting a session, you can select the specific agent best suited for the task.

  • Security: This tool is designed for local/personal use only. It does not have enterprise-grade security (encryption/auth) and should not be deployed to public networks.
  • Platform: Currently optimized for Windows.

GLM Coding Plan in Claude Code: Zhipu AI Integration Guide

Use Zhipu AI’s GLM models in Claude Code with the official GLM Coding Plan integration. A complete guide to installation, configuration, and daily usage.


Claude Code is an intelligent coding tool that runs in the terminal, helping developers quickly complete code generation, debugging, refactoring, and other tasks through natural language commands. But what if you want to use China’s powerful GLM models instead?

GLM Coding Plan is the official solution from Zhipu AI that integrates GLM models directly into Claude Code. With this integration, you can leverage models like GLM-4.7 and GLM-4.5-Air while keeping the familiar Claude Code workflow.

This guide covers everything you need to know: from installation to advanced configuration, troubleshooting, and best practices.


Before you begin, ensure you have:

  • Node.js 18 or newer installed
  • Git for Windows (Windows users only)
  • A Zhipu AI account with API access

Open your terminal and run:

Terminal window
npm install -g @anthropic-ai/claude-code

Verify the installation:

Terminal window
claude --version
# Output: 2.0.14 (Claude Code) or higher

Tip: If you’re not familiar with Node.js and have Cursor installed, you can type Help me install Claude Code in Cursor, and it will guide you through the installation process.

Zhipu AI provides two integration approaches:

Approach A: Environment Variables (Quick Start)

Section titled “Approach A: Environment Variables (Quick Start)”

Set the following environment variables in your terminal:

Terminal window
export ANTHROPIC_BASE_URL="https://open.bigmodel.cn/api/paas/v4/"
export ANTHROPIC_AUTH_TOKEN="your_zhipu_api_key"
export ANTHROPIC_MODEL="glm-4.7"

Or add them to your shell config (~/.zshrc or ~/.bashrc):

Terminal window
cat >> ~/.zshrc <<'EOF'
# GLM Coding Plan Configuration
export ANTHROPIC_BASE_URL="https://open.bigmodel.cn/api/paas/v4/"
export ANTHROPIC_AUTH_TOKEN="your_zhipu_api_key"
export ANTHROPIC_MODEL="glm-4.7"
EOF
source ~/.zshrc

Edit ~/.claude/settings.json:

{
"env": {
"ANTHROPIC_BASE_URL": "https://open.bigmodel.cn/api/paas/v4/",
"ANTHROPIC_AUTH_TOKEN": "your_zhipu_api_key",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.7",
"ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.7"
}
}

Navigate to your project directory and run:

Terminal window
claude

When prompted “Do you want to use this API key?”, select Yes. Then trust Claude Code to access your project files.


ModelUse CaseSpeedQuality
GLM-4.7Complex reasoning, architecture designMediumHighest
GLM-4.5-AirQuick tasks, simple queriesFastGood
GLM-4.5Balanced performanceMediumHigh
  • Use GLM-4.7 for: feature implementation, code refactoring, architectural decisions
  • Use GLM-4.5-Air for: quick fixes, documentation, simple queries
  • Use GLM-4.5 for: general development tasks

Terminal window
# Navigate to your project
cd my-project
# Start Claude Code with GLM
claude
# In Claude Code:
> Add user authentication with JWT tokens
> Write unit tests for the auth module
> Review and optimize the database queries
Terminal window
claude
# In Claude Code:
> Refactor the User class to follow SOLID principles
> Extract the validation logic into a separate service
> Add TypeScript types to the entire module
Terminal window
claude
# In Claude Code:
> Investigate why the API returns 500 errors
> Add comprehensive error logging
> Write a test case for this bug

You can switch models without restarting Claude Code by modifying the environment variable:

Terminal window
# Switch to faster model for quick tasks
export ANTHROPIC_MODEL="glm-4.5-air"
# Switch to more powerful model for complex tasks
export ANTHROPIC_MODEL="glm-4.7"

Then verify with /status in Claude Code:

Current model: glm-4.7
Base URL: https://open.bigmodel.cn/api/paas/v4/

GLM Coding Plan supports additional MCP servers for enhanced capabilities:

Enable image understanding capabilities:

{
"mcpServers": {
"vision": {
"command": "node",
"args": ["path/to/vision-mcp-server.js"]
}
}
}

Add web search capabilities:

{
"mcpServers": {
"search": {
"command": "node",
"args": ["path/to/search-mcp-server.js"]
}
}
}

Enable web page reading:

{
"mcpServers": {
"web-reader": {
"command": "node",
"args": ["path/to/web-reader-mcp.js"]
}
}
}

Symptoms: You modified ~/.claude/settings.json but changes don’t take effect.

Solutions:

  1. Restart Claude Code completely - Close all terminal windows and start fresh:

    Terminal window
    claude
  2. Verify JSON syntax - Use a JSON validator to check for syntax errors:

    Terminal window
    cat ~/.claude/settings.json | python -m json.tool
  3. Reset configuration - Delete the file and reconfigure:

    Terminal window
    rm ~/.claude/settings.json
    claude # Will prompt for reconfiguration

Symptoms: “Unauthorized” or “Invalid API key” errors.

Solutions:

  1. Verify your API key in the Zhipu AI Console
  2. Check for extra spaces or quotes in your environment variables
  3. Ensure the ANTHROPIC_AUTH_TOKEN is set correctly

Symptoms: GLM models take too long to respond.

Solutions:

  1. Switch to glm-4.5-air for faster responses
  2. Increase timeout if needed:
    Terminal window
    export API_TIMEOUT_MS=600000 # 10 minutes
  3. Check your network connection to the Zhipu API

Task TypeRecommended Model
Quick fixesGLM-4.5-Air
Feature implementationGLM-4.7
Code reviewGLM-4.7
DocumentationGLM-4.5-Air
DebuggingGLM-4.7
Simple queriesGLM-4.5-Air

Always run Claude Code from your project root directory. This helps Claude understand:

  • Project structure and dependencies
  • Build configurations
  • Test setups
  • Coding conventions

Break complex tasks into smaller steps:

1. "Create the user schema"
2. "Add CRUD operations for users"
3. "Write tests for user operations"
4. "Add input validation"
5. "Document the API endpoints"

Claude Code works best when you provide context:

  • Share error messages completely
  • Show relevant code snippets
  • Explain the business requirements
  • Describe expected behavior

Zhipu AI validates GLM Coding Plan on Claude Code 2.0.14+. To check and upgrade:

Terminal window
# Check current version
claude --version
# Upgrade to latest version
claude update

Always keep Claude Code updated for the best compatibility with GLM models.


FeatureGLM Coding PlanDirect AnthropicOther China LLMs
Setup ComplexityLowMediumVaries
Chinese UnderstandingExcellentGoodExcellent
Code QualityHighVery HighMedium-High
CostCompetitiveHigherVaries
Local DataYesNoVaries
Official SupportYesN/ALimited

Q: Can I use GLM Coding Plan alongside other Claude Code configurations?

Section titled “Q: Can I use GLM Coding Plan alongside other Claude Code configurations?”

A: Yes, you can switch between different API providers by changing environment variables or creating multiple profiles in your settings file.

Q: Is my code data sent to Zhipu AI servers?

Section titled “Q: Is my code data sent to Zhipu AI servers?”

A: Yes, similar to how Claude Code sends data to Anthropic. Review Zhipu AI’s data privacy policy for details on data handling and retention.

Q: Can I use GLM Coding Plan in Cursor or other IDEs?

Section titled “Q: Can I use GLM Coding Plan in Cursor or other IDEs?”

A: GLM Coding Plan is primarily designed for terminal-based Claude Code. However, you can configure similar API settings in Cursor if it supports custom endpoints.

Q: What’s the difference between GLM-4.7 and GLM-4.5-Air?

Section titled “Q: What’s the difference between GLM-4.7 and GLM-4.5-Air?”

A: GLM-4.7 is Zhipu’s most capable model for complex reasoning tasks, while GLM-4.5-Air is optimized for speed and cost efficiency on simpler tasks.

Q: How do I check which model is currently active?

Section titled “Q: How do I check which model is currently active?”

A: Run /status command in Claude Code to see the current model and configuration.



GLM Coding Plan brings the power of Zhipu AI’s GLM models to Claude Code, offering a compelling alternative for developers who prefer China-hosted models or need better Chinese language understanding. With proper configuration and model selection, you can achieve productivity gains while maintaining data locality.

The integration is straightforward, the documentation is comprehensive, and the official support from Zhipu AI ensures a smooth experience. Whether you’re building new features or debugging existing code, GLM Coding Plan has you covered.

Happy coding with GLM!

Superpowers: Transform Claude Code Into a Disciplined Development Workflow Engine

What if Claude Code could enforce engineering discipline instead of just writing code? That’s exactly what obra/superpowers delivers—a complete software development workflow system built on composable “skills” that automatically activate to guide your development process.

With over 11,800 stars and 960 forks on GitHub, Superpowers has become the go-to framework for developers who want their AI coding assistant to follow systematic engineering practices rather than ad-hoc code generation.

Claude Code Superpowers Workflow


The Core Philosophy: Engineering Discipline Over Quick Fixes

Section titled “The Core Philosophy: Engineering Discipline Over Quick Fixes”

Superpowers enforces four fundamental principles:

PrincipleDescription
Test-Driven DevelopmentWrite tests first, always. Code written before tests may be deleted
Systematic over Ad-hocFollow defined processes rather than guessing
Complexity ReductionSimplicity as the primary goal (YAGNI, DRY)
Evidence over ClaimsVerify fixes work before declaring success

This isn’t about adding more features—it’s about fundamentally changing how AI agents approach software development.


How Superpowers Works: The Five-Phase Workflow

Section titled “How Superpowers Works: The Five-Phase Workflow”

When you start a project with Superpowers enabled, Claude Code follows a structured workflow:

Instead of immediately writing code, the agent “steps back and asks what you’re really trying to do.” Through Socratic dialogue, it:

  • Explores your requirements through questions
  • Considers alternatives and edge cases
  • Presents design in digestible chunks for approval
  • Saves a specification document

After design approval, it creates an implementation plan that’s “clear enough for an enthusiastic junior engineer” to follow:

  • Breaks work into 2-5 minute tasks
  • Specifies exact file paths and code locations
  • Includes verification steps for each task
  • Emphasizes TDD, YAGNI, and DRY principles

Phase 3: Isolated Development (Git Worktrees)

Section titled “Phase 3: Isolated Development (Git Worktrees)”

The system creates isolated workspaces:

Terminal window
# Superpowers automatically:
# 1. Creates a new branch via git worktree
# 2. Runs project setup
# 3. Verifies test baseline (all tests must pass before changes)

Here’s where the magic happens—autonomous execution with quality gates:

  • Fresh subagents handle individual tasks
  • Two-stage review: specification compliance, then code quality
  • The docs note: “It’s not uncommon for Claude to work autonomously for a couple hours at a time”
  • Verifies all tests pass
  • Offers merge or PR options
  • Cleans up worktrees
  • Presents summary with code review prompt

Terminal window
# 1. Register the marketplace
/plugin marketplace add obra/superpowers-marketplace
# 2. Install superpowers
/plugin install superpowers@superpowers-marketplace
# 3. Verify installation
/help
# You should see: /superpowers:brainstorm, /superpowers:write-plan, /superpowers:execute-plan

Tell Codex to fetch and follow:

https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.codex/INSTALL.md

Tell OpenCode to fetch and follow:

https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md
Terminal window
/plugin update superpowers

Superpowers includes a comprehensive set of skills organized by category:

SkillPurpose
test-driven-developmentEnforces RED-GREEN-REFACTOR cycle with anti-patterns reference
SkillPurpose
systematic-debugging4-phase root cause analysis process
verification-before-completionEnsures fixes are actually verified before marking complete
SkillPurpose
brainstormingInteractive Socratic design refinement
writing-plansCreates detailed implementation plans with exact file paths
executing-plansBatch execution with human checkpoints
dispatching-parallel-agentsManages concurrent subagent workflows
requesting-code-reviewPre-review checklist system
receiving-code-reviewStructured feedback response workflow
using-git-worktreesParallel development branch management
finishing-a-development-branchMerge/PR decision workflow with cleanup
subagent-driven-developmentFast iteration with two-stage review
SkillPurpose
writing-skillsGuidelines for creating new skills with testing methodology
using-superpowersIntroduction to the skills system

User: I want to add user authentication with OAuth2
Claude (with Superpowers):
1. [brainstorming activates] Let me understand your requirements...
- What OAuth providers do you need?
- Session or JWT tokens?
- Required permission scopes?
2. [After discussion] Here's the design spec. [Saves to file]
3. [writing-plans activates] Here's the implementation plan:
- Task 1: Set up OAuth configuration (3 min)
- Task 2: Write auth callback tests (5 min)
- Task 3: Implement callback handler (5 min)
...
4. [subagent-driven-development] Executing tasks autonomously with reviews...
5. [finishing-a-development-branch] All tests passing. Merge or create PR?
User: Users are getting logged out randomly
Claude (with Superpowers):
[systematic-debugging activates]
Phase 1: Root Cause Tracing
- Analyzing session management code...
- Checking token expiration logic...
- Found: Token refresh race condition
Phase 2: Defense in Depth
- Multiple potential fixes identified
- Recommended: Add token refresh mutex
Phase 3: Implementation with TDD
[test-driven-development activates]
- Writing failing test for race condition
- Implementing fix
- Verifying test passes
Phase 4: Verification
[verification-before-completion activates]
- Running full test suite
- Simulating concurrent requests
- Confirmed: Issue resolved

Skills trigger automatically based on context—no manual commands needed. The agent checks for relevant skills before any task, making these mandatory workflows, not suggestions.

Code review happens between tasks, blocking progress on critical issues. This ensures problems are caught early rather than accumulating.

The system actually deletes code written before tests exist. This enforces discipline that even experienced developers sometimes skip.

Implementation plans include:

  • Exact file paths
  • Complete code snippets
  • Verification steps
  • Time estimates (2-5 minutes per task)

FeatureSuperpowersGeneric Claude CodeCursor + Rules
Automatic workflow activationYesNoPartial
TDD enforcementYes (deletes pre-test code)NoNo
Subagent orchestrationYesLimitedNo
Git worktree managementYesManualNo
Quality gates between tasksYesNoNo
Autonomous executionUp to 2 hoursPer requestPer request

  1. Trust the process - Let Superpowers guide you through design before coding
  2. Provide context - The more you share during brainstorming, the better the implementation
  3. Review checkpoints - Use human checkpoints to validate direction
  4. Update regularly - Run /plugin update superpowers for latest skills
  1. Don’t skip brainstorming - Rushing to code defeats the purpose
  2. Don’t ignore test failures - Fix before continuing
  3. Don’t bypass quality gates - They exist for good reasons
  4. Don’t forget to verify - Ensure fixes actually work

Q: Skills aren’t activating automatically? A: Run /help to verify installation. If skills don’t appear, try reinstalling.

Q: Can I create custom skills? A: Yes! Use the writing-skills skill as a guide. Skills live in the repository for direct contribution via PRs.

Q: How do I skip a workflow step? A: You can override, but it’s not recommended. The system is designed as a complete workflow.

Q: Does it work with non-TypeScript projects? A: Yes, the skills are language-agnostic. The principles apply to any codebase.


  1. Fork the repository
  2. Create a branch for your skill
  3. Follow the writing-skills guidelines
  4. Submit a PR

The complete guide is in skills/writing-skills/SKILL.md.



Superpowers represents a paradigm shift from “AI writes code” to “AI follows engineering discipline.” By making structured workflows mandatory rather than optional, it produces higher-quality code through autonomous but systematic development processes.

If you’ve been frustrated by AI assistants that generate code without proper testing or design consideration, Superpowers is your solution. Install it today and transform Claude Code into the disciplined engineering partner you deserve.


Ready to level up your Claude Code experience?

Terminal window
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Your future self (and your test suite) will thank you.

🎚️ CodexBar: macOS Menu Bar Usage Stats for Claude Code & OpenAI Codex

CodexBar is a tiny macOS 15+ menu bar app created by Peter Steinberger (@steipete) that keeps your AI coding assistant usage limits always visible. Monitor both OpenAI Codex and Claude Code limits - including 5-hour session windows and weekly caps - without logging into any dashboard.

  • Dual provider support: Track both Codex (5h/weekly + credits) and Claude Code (session/weekly + Sonnet-only limits) simultaneously
  • Zero login required: Reads directly from local CLI output - no passwords, no browser sessions needed
  • Real-time visibility: See remaining tokens, reset timers, and account info from your menu bar

If you’re actively using Claude Code or OpenAI Codex for development, you’ve likely hit rate limits unexpectedly. Here’s why CodexBar is essential:

  1. Avoid workflow interruptions Know your remaining quota before starting a major coding session. No more “rate limited” surprises in the middle of complex refactoring.

  2. Track multiple time windows Both services use overlapping 5-hour and weekly windows. CodexBar visualizes both so you understand exactly when limits reset.

  3. Monitor Sonnet-only limits (Claude) Claude Code’s Sonnet model has its own weekly cap. CodexBar shows this separately so you can strategically choose when to use which model.

  4. Credits visibility (Codex) See your paid credits balance alongside rate limits. Know when you’re burning through free tier vs. paid usage.


Terminal window
brew install --cask steipete/tap/codexbar

Update via:

Terminal window
brew upgrade --cask steipete/tap/codexbar

Download the ready-to-run zip from GitHub Releases.


  • macOS 15+ (Sequoia or later)
  • For Codex: Codex CLI ≥ 0.55.0 installed and logged in
  • For Claude Code: Claude CLI installed via claude --version and logged in via claude login

CodexBar auto-detects installed CLIs on first launch:

  • Codex enabled by default
  • Claude turns on automatically when claude binary is present

CodexBar runs claude /usage and claude /status in a local PTY (pseudo-terminal) to extract:

  • Session usage percentage
  • Weekly usage percentage
  • Sonnet-only weekly limit
  • Reset countdown timers
  • Account email, organization, and login method

Privacy note: Everything stays local. No network calls beyond what the Claude CLI itself makes.

CodexBar prefers the Codex app-server RPC for rate limits and credits. Falls back to PTY scrape of codex /status if RPC unavailable.

Optional “Access OpenAI via web” setting adds:

  • Code review remaining
  • Usage breakdown
  • Credits usage history

This reuses existing signed-in chatgpt.com session via Safari/Chrome cookie import - no passwords stored.


The menu bar icon uses a clever two-bar system:

BarWhat It Shows
Top bar5-hour window quota (or credits bar if weekly exhausted)
Bottom barWeekly window quota (thin line)

Icon variants:

  • Codex mode: Features the signature “eyelid blink” design
  • Claude mode: Shows Claude’s notch/leg variant
  • Errors/unknowns: Icon dims (no confusing text)

Menu → “Refresh every…” offers these presets:

  • Manual only
  • 1 minute
  • 2 minutes
  • 5 minutes (default)
  • 15 minutes

Manual mode still allows on-demand “Refresh now” from the menu.


CodexBar is designed with privacy in mind:

  • No disk scanning - See issue #12 for audit notes
  • Per-provider data isolation - Claude info never mixes with Codex info
  • Local CLI reading only - Account details come directly from CLI output
  • No password storage - Optional web access uses existing browser cookies

CodexBar is part of a suite of developer productivity tools from steipete:

ToolDescription
TrimmyFlatten multi-line shell snippets for paste-and-run
MCPorterTypeScript toolkit + CLI for MCP servers

Inspiration: ccusage - CLI tool for Claude Code usage cost tracking (which we’ve covered previously).


ScenarioBehavior
No Codex usage yetShows “No usage yet” - run one prompt and refresh
Claude CLI missingShows “Claude CLI is not installed”
Not logged inShows respective login error
Reset time parsing failsSurfaces raw text when timezone info missing

CodexBar solves a real pain point for heavy AI coding assistant users:

  • ✅ See both Codex and Claude Code limits at a glance
  • ✅ Monitor 5-hour sessions AND weekly windows
  • ✅ Track Sonnet-specific limits and paid credits
  • ✅ Zero login required - reads local CLI data
  • ✅ Privacy-first design with no disk scanning

Install it via brew install --cask steipete/tap/codexbar and never be surprised by rate limits again.


📌 Want more Claude Code tips, usage optimization strategies, and AI developer tools? Follow our channel for the latest guides on maximizing your AI-assisted development workflow!

Boris Cherny: How the Creator of Claude Code Grew His Career from Meta to Anthropic

Behind every revolutionary product is a story of personal growth, strategic thinking, and relentless curiosity. Boris Cherny, the creator of Claude Code at Anthropic, exemplifies this truth. His journey from startups to venture capital, through a decade at Meta (Facebook/Instagram), to leading one of the most impactful AI developer tools demonstrates key principles that any engineer can apply.

This article distills Boris’s career insights, revealing how he went from a mid-level engineer to principal at Meta, and finally to creating Claude Code—a tool that now writes 80-90% of its own codebase.

Boris Cherny Career Growth


Boris started his first startup at 18, worked at a hedge fund, and notably has no CS degree—he studied economics before dropping out to pursue startups. His trajectory proves that programming is a practical skill learned on the job, not in classrooms.

Key milestones at Meta (2012-2022):

  • IC4 (Mid-level): Joined “under-leveled” working on Messenger-Groups integration
  • IC5-IC6: Led Groups web migration; created the Undux state management library
  • IC7 (Senior Staff): Drove Public Groups feature with complex data model migrations
  • IC8 (Principal): Scoped work for hundreds of engineers; led Instagram’s Python-to-Hack migration

1. Design for the Model Six Months from Now

Section titled “1. Design for the Model Six Months from Now”

In the fast-evolving AI landscape, don’t build for current model capabilities—design for future ones.

“Don’t build for today’s model, build for the model six months from now.” — Ben Mann, Boris’s manager at Anthropic

This forward-thinking approach explains why Claude Code initially felt underwhelming but became transformative after Claude 4 series launched. Early products may have mediocre experiences, but when new models drop, you achieve quantum leaps.

The most successful products don’t invent new behaviors—they satisfy hidden, existing ones.

Boris observed at Facebook that users were “abusing” Groups for commerce 40% of the time. This observation birthed Facebook Marketplace. Similarly, Dating emerged from observing how people were already using the platform for connections.

Lesson: Watch what users are hacking together with your existing features—that’s where product-market fit hides.

3. Side Projects Are Your Biggest Career Lever

Section titled “3. Side Projects Are Your Biggest Career Lever”

Through solving repeated pain points and promoting solutions as company-wide tools, Boris accumulated cross-team influence rapidly.

His “20% time” projects included:

  • Undux: A state management library for React
  • TypeScript Book & Meetup: Community building in the developer space
  • Lint Rule Automation: Turning repeated code review comments into automated checks
  • Large Dataset Testing Framework: Infrastructure benefiting thousands of engineers

“Better engineering is the easiest way to grow your network and gain influence as an engineer.”

4. Become a Generalist Who Breaks Swim Lanes

Section titled “4. Become a Generalist Who Breaks Swim Lanes”

High-impact engineers don’t just write code—they develop product sense, design ability, and user research skills.

At both Meta and Anthropic, there are no formal titles. Everyone is a “Member of Technical Staff” regardless of whether they’re an engineer, PM, or designer. This culture forces constant re-validation through execution rather than title.

“Just because you’re a product engineer doesn’t mean you can’t build infra.”

In complex organizations with historical baggage and process inertia, the most reliable decision-making framework is returning to basics:

  • What does the user actually need?
  • Does this make sense?

Rather than being led by organizational momentum, successful leaders constantly ask these fundamental questions.


Claude Code started as an accidental discovery during internal experiments at Anthropic. Boris’s manager pushed beyond autocomplete thinking, encouraging design for future model capabilities.

Initially, Boris only used Claude Code for about 10% of his work. The product wasn’t viable until Sonnet/Opus 4 launched in March 2024.

After model improvements, usage jumped to 50% of coding work. Today, 80-90% of Claude Code is written by Claude Code itself. Surprisingly, adoption spread beyond engineers to data scientists and sales teams—unexpected use cases the team hadn’t anticipated.


Hiring Philosophy: Look for “Side Quests”

Section titled “Hiring Philosophy: Look for “Side Quests””

Boris actively seeks engineers with curiosity beyond daily work:

“When I hire engineers, this is definitely something I look for… cool weekend projects, like someone who’s really into making kombucha.”

This signals growth mindset and intellectual curiosity—traits that separate good engineers from great ones.


On imposter syndrome:

“No one knows what they’re doing at any level. If you don’t feel it, you’re not pushing hard enough.”

On focus vs. breadth:

“Writing code anchors you to reality. Without it, you lose intuition quickly—dangerous place to be.”

On team dynamics:

“You never want to tell anyone what to do. Understand what they want, then present opportunity—it always works better.”

On organizational change:

“Just do it. Sometimes you need consensus, sometimes you act. Leaders juggle both constantly.”


  1. Stop chasing titles—pursue interesting problems and impact. Promotions follow naturally.

  2. Invest in side projects—even small automations that help your team compound into massive influence over time.

  3. Become the generalist—learn product, design, and user research alongside engineering. The most valuable engineers are those who can wear multiple hats.

  4. Apply common sense liberally—when lost in organizational complexity, ask “what does the user actually need?”

  5. Build for the future—whether in AI or any fast-moving field, design for where technology will be, not where it is today.


Boris Cherny’s career offers a masterclass in engineering growth: start by solving your own problems, scale solutions to help others, earn trust through execution rather than titles, and always design for the future.

Claude Code exists because Boris spent a decade building products (many failed), learning what great developer experience feels like, and positioning himself at the intersection of code quality and AI capability.

For engineers seeking rapid career growth, his formula is clear: Be curious. Build side projects. Think in systems. Design for tomorrow.


Continuous Claude: The Ultimate Context Management System for Claude Code

Continuous Claude: The Ultimate Context Management System for Claude Code

Section titled “Continuous Claude: The Ultimate Context Management System for Claude Code”

When working with Claude Code on complex projects, you’ve likely encountered the frustrating “context degradation” problem. After several compaction cycles, you’re essentially working with a summary of a summary of a summary. Signal degrades into noise, and Claude starts hallucinating context.

Continuous Claude solves this fundamental problem through a revolutionary approach: clear, don’t compact.

The Core Problem: Context Compaction Decay

Section titled “The Core Problem: Context Compaction Decay”
Session Start: Full context, high signal
↓ work, work, work
Compaction 1: Some detail lost
↓ work, work, work
Compaction 2: Context getting murky
↓ work, work, work
Compaction 3: Now working with compressed noise
↓ Claude starts hallucinating context

Traditional approaches try to optimize compaction algorithms. Continuous Claude takes a fundamentally different path: preserve state externally, clear context completely, resume with full signal.

Session Start: Fresh context + ledger loaded
↓ focused work
Complete task, save to ledger
↓ /clear
Fresh context + ledger loaded
↓ continue with full signal
  • Ledgers are lossless - You control exactly what’s saved
  • Fresh context = full signal - No degraded summaries
  • Agents spawn clean - Each agent gets isolated context windows

Within-Session (Ledger)

Before running /clear:

"Update the ledger, I'm about to clear"

Creates/updates CONTINUITY_CLAUDE-<session>.md with:

  • Goal and constraints
  • What’s done, what’s next
  • Key decisions
  • Working files

Between-Sessions (Handoff)

When done for the day:

"Create a handoff, I'm done for today"

Creates detailed handoff with:

  • Complete context
  • Recent changes with file:line references
  • Learnings and patterns
  • Next steps

Continuous Claude uses a sophisticated hook system that intercepts Claude Code lifecycle events:

EventWhenWhat It Does
SessionStartNew session, /clear, compactLoads ledger + latest handoff into context
PreCompactBefore context compactionCreates auto-handoff, blocks manual compact
UserPromptSubmitBefore processing user messageShows skill suggestions, context warnings
PostToolUseAfter Edit/Write/BashTracks modified files for auto-summary
SubagentStopAgent finishesLogs agent completion
SessionEndSession closesCleanup temp files

3. MCP Code Execution Without Context Pollution

Section titled “3. MCP Code Execution Without Context Pollution”

Tools are executed via scripts, not loaded into context. This saves significant tokens:

Terminal window
# Example: run a script
uv run python -m runtime.harness scripts/qlty_check.py --fix

For complex implementations, the implement_plan orchestrator spawns task agents:

implement_plan (orchestrator)
├── task-agent (task 1) → handoff-01.md
├── task-agent (task 2) → handoff-02.md
└── task-agent (task 3) → handoff-03.md

Each task agent:

  1. Reads previous handoff
  2. Does its work with TDD
  3. Creates handoff for next agent
  4. Returns summary to orchestrator
Terminal window
# Clone
git clone https://github.com/parcadei/Continuous-Claude.git
cd Continuous-Claude
# Install Python deps
uv sync
# Configure (optional - add API keys for extra features)
cp .env.example .env
# Start
claude
Terminal window
# After cloning and syncing
./install-global.sh
Terminal window
cd your-project
~/.claude/scripts/init-project.sh

Continuous Claude responds to natural language. Say certain phrases and Claude activates the right skill or spawns an agent.

Say ThisWhat Happens
”save state”, “update ledger”, “before clear”Updates continuity ledger
”done for today”, “wrap up”, “create handoff”Creates detailed handoff doc
”resume work”, “continue from handoff”Loads handoff, continues
Say ThisWhat Happens
”create plan”, “design”, “architect”Spawns plan-agent
”validate plan”, “before implementing”Spawns validate-agent
”implement plan”, “execute plan”Spawns implement_plan
Say ThisWhat Happens
”implement”, “add feature”, “fix bug”TDD workflow activates
”lint”, “code quality”, “auto-fix”Runs qlty-check
”commit”, “push”, “save changes”Runs commit skill

The colored status bar shows context usage:

45.2K 23% | main U:3 | ✓ Fixed auth → Add tests

Color coding:

  • 🟢 Green (< 60%): Normal
  • 🟡 Yellow (60-79%): Warning - consider handoff soon
  • 🔴 Red (≥ 80%): Critical - create handoff now

Skills run in current context - quick, focused, minimal token overhead.

Agents spawn with fresh context - use for complex tasks that would degrade in compacted context.

  • Brownfield exploration → rp-explorer
  • Multi-step research → research-agent
  • Complex debugging → debug-agent
  • Implementation with handoffs → implement_plan

Track every session for learning from past work:

  1. Session traces - Every turn, tool call, and LLM response logged
  2. Automatic learnings - Extracts “What Worked/Failed/Patterns” at session end
  3. Artifact Index integration - Handoffs linked to trace IDs

Transform session learnings into permanent rules:

"compound my learnings"
→ Analyzes .claude/cache/learnings/*.md
→ Identifies recurring patterns
→ Creates new rules in .claude/rules/
.claude/
├── skills/ # Skill definitions (SKILL.md)
├── hooks/ # Session lifecycle (TypeScript)
├── agents/ # Agent configurations
├── rules/ # Behavioral rules
└── settings.json # Hook registrations
scripts/ # MCP workflow scripts
thoughts/ # Research, plans, handoffs

Comparison: Traditional vs Continuous Claude

Section titled “Comparison: Traditional vs Continuous Claude”
AspectTraditional ApproachContinuous Claude
Context DegradationCumulative lossZero loss
Session ContinuityManual notesAutomated ledgers
Agent ContextInherited degradedFresh isolated
Learning LoopNoneCompound learnings
Token EfficiencyTools loaded in contextScripts executed externally
  1. Update ledger before /clear - Always save state first
  2. Create handoffs at stopping points - Don’t wait until context is critical
  3. Use agents for complex tasks - They get clean context
  4. Leverage compound learnings - Turn patterns into rules
  5. Watch the StatusLine - It shows when to create handoffs

Continuous Claude represents a paradigm shift in how we approach context management for AI coding assistants. By embracing “clear, don’t compact” and building robust state preservation through ledgers and handoffs, it enables:

  • Lossless context preservation across sessions
  • Token-efficient MCP execution without context pollution
  • Intelligent agent orchestration with isolated context windows
  • Continuous learning that improves over time

For teams working on complex, long-running projects with Claude Code, Continuous Claude is an essential addition to your development toolkit.

OpenSkills: Universal Skills Loader for AI Coding Agents

OpenSkills: Universal Skills Loader for AI Coding Agents

Section titled “OpenSkills: Universal Skills Loader for AI Coding Agents”

AI coding agents have revolutionized software development, but each agent operates in its own ecosystem with unique capabilities. OpenSkills bridges this gap by bringing Anthropic’s powerful skills system to all AI coding agents.

OpenSkills is a universal skills loader that implements Anthropic’s Agent Skills specification for any AI coding agent. It brings Claude Code’s skills system to Cursor, Windsurf, Aider, and other agents with 100% compatibility.

Terminal window
npm i -g openskills
openskills install anthropics/skills
openskills sync

Each AI coding agent has its own way of handling specialized capabilities:

  • Claude Code has a built-in skills system with marketplace
  • Cursor uses custom rules and instructions
  • Windsurf has its own knowledge management
  • Aider relies on conventions and prompts

This fragmentation means skills and workflows don’t transfer between agents.

OpenSkills provides a unified skills format that works across all agents:

  • Same prompt format - <available_skills> XML structure
  • Same marketplace - Access Anthropic’s official skills
  • Same folder structure - Uses .claude/skills/ by default
  • Same SKILL.md format - YAML frontmatter + markdown instructions
  • Progressive disclosure - Load skills on demand, not upfront

OpenSkills works with any AI coding agent by using CLI commands instead of proprietary tool calls:

AspectClaude CodeOpenSkills
InvocationSkill("pdf")openskills read pdf
Prompt Format<available_skills> XMLIdentical
Folder Structure.claude/skills/Identical
SKILL.md FormatYAML + markdownIdentical

Install skills from various sources:

Terminal window
# Anthropic's official marketplace
openskills install anthropics/skills
# Any GitHub repository
openskills install your-org/custom-skills
# Local paths
openskills install ./local-skills/my-skill
# Private git repos
openskills install git@github.com:your-org/private-skills.git

Skills load only when needed, keeping your agent’s context clean and focused. When the agent needs a skill:

  1. Agent scans <available_skills> in AGENTS.md
  2. Agent executes openskills read <skill-name>
  3. Full skill instructions load into context
  4. Agent follows instructions to complete task

Skills can include supporting resources:

my-skill/
├── SKILL.md # Main instructions
├── references/
│ └── api-docs.md # Supporting documentation
├── scripts/
│ └── process.py # Helper scripts
└── assets/
└── template.json # Templates, configs
Terminal window
npm i -g openskills

Requires Node.js 20.6+ and Git.

Terminal window
# Interactive selection from marketplace
openskills install anthropics/skills
# Install all skills non-interactively
openskills install anthropics/skills -y

Available skills from Anthropic’s marketplace:

  • pdf - PDF manipulation (extract, merge, split, forms)
  • xlsx - Spreadsheet creation and analysis
  • docx - Document creation with tracked changes
  • pptx - Presentation creation and editing
  • canvas-design - Create posters and visual designs
  • mcp-builder - Build Model Context Protocol servers
  • skill-creator - Guide for authoring skills
Terminal window
openskills sync

This updates your AGENTS.md file with the <available_skills> section:

<skills_system priority="1">
<available_skills>
<skill>
<name>pdf</name>
<description>Comprehensive PDF manipulation toolkit...</description>
<location>project</location>
</skill>
</available_skills>
</skills_system>
Terminal window
# Project-local (default, gitignored)
openskills install anthropics/skills
# Global (shared across all projects)
openskills install anthropics/skills --global

If you use Claude Code alongside other agents:

Terminal window
openskills install anthropics/skills --universal

This installs to .agent/skills/ to avoid conflicts with Claude Code’s native marketplace.

Priority order:

  1. ./.agent/skills/ (project universal)
  2. ~/.agent/skills/ (global universal)
  3. ./.claude/skills/ (project)
  4. ~/.claude/skills/ (global)

For active skill development:

Terminal window
# Clone your skills repo
git clone git@github.com:your-org/my-skills.git ~/dev/my-skills
# Symlink into project
mkdir -p .claude/skills
ln -s ~/dev/my-skills/my-skill .claude/skills/my-skill
# Changes reflect immediately
openskills sync
---
name: my-skill
description: What this does and when to use it
---
# Instructions
When the user asks you to X, do Y...
my-skill/
├── SKILL.md
├── references/ # Supporting docs
├── scripts/ # Helper scripts
└── assets/ # Templates, configs
  1. Create a GitHub repository with your skill
  2. Users install with: openskills install username/repo-name

Use OpenSkills to share skills across your organization regardless of which AI agent team members prefer:

Terminal window
# Team repository with shared skills
openskills install your-org/team-skills

Install skills from any GitHub repository, not just Anthropic’s marketplace:

Terminal window
openskills install community-user/useful-skills

Keep proprietary skills in private repositories:

Terminal window
openskills install git@github.com:enterprise/internal-skills.git

Use the same skills whether you’re in Claude Code, Cursor, or Windsurf:

Terminal window
# Works everywhere
openskills read pdf

OpenSkills uses CLI commands rather than MCP (Model Context Protocol) because:

  1. Skills are static instructions - Not dynamic tools requiring server connections
  2. No server needed - Skills are just markdown files
  3. Universal compatibility - CLI works with any agent
  4. Follows Anthropic’s design - Skills were designed as SKILL.md files
  5. Simpler for users - No server management required

MCP and skills solve different problems. OpenSkills implements the skills spec as designed.

Each skill should handle one specific domain. Don’t create “do everything” skills.

The description helps agents decide when to load the skill:

description: Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms

Put detailed instructions in SKILL.md, not the description. This keeps the <available_skills> section compact.

Help agents understand how to use your skill with concrete examples in the instructions.

FeatureOpenSkillsCustom PromptsMCP
UniversalYesPer-agentRequires support
Progressive LoadingYesNoYes
Marketplace AccessYesNoDifferent
Setup ComplexityLowVariesHigher
Bundled ResourcesYesLimitedYes

OpenSkills democratizes AI agent skills by making Anthropic’s well-designed skills system available to all agents. Whether you’re using Claude Code, Cursor, Windsurf, or Aider, you can now benefit from:

  • Standardized skills format across agents
  • Access to Anthropic’s marketplace via GitHub
  • Progressive disclosure for clean contexts
  • Easy skill sharing within teams and communities

Get started today:

Terminal window
npm i -g openskills
openskills install anthropics/skills
openskills sync

Personal AI Infrastructure (PAI): Build Your Own AI-Powered Operating System

Personal AI Infrastructure (PAI): Build Your Own AI-Powered Operating System

Section titled “Personal AI Infrastructure (PAI): Build Your Own AI-Powered Operating System”

Right now, the most powerful AI setups are being built inside companies for efficiency and profits. But what if you could have the same sophisticated AI infrastructure available to everyone? That’s exactly what Personal AI Infrastructure (PAI) delivers.

Created by security researcher and AI pioneer Daniel Miessler, PAI is an open-source template for building your own AI-powered operating system. It’s the foundation for creating a Personal AI System that understands your larger goals and context, gets better over time, and works for you because it’s yours.

PAI (Personal AI Infrastructure) is open-source scaffolding built on Claude Code, designed to be platform-independent. The architecture, skills, and workflows are structured so future migrations to other AI platforms remain straightforward.

“The best AI in the world should be available to everyone.”

The purpose of technology is to serve humans—not the other way around. PAI enables regular people to use AI to help them flourish, not just tech workers inside corporations.

Skills are self-contained AI capabilities with routing, workflows, and documentation. Each skill follows the “skills-as-containers” pattern:

ComponentDescription
SkillsDomain expertise encoded as reusable modules (security analysis, content creation, research workflows)
AgentsSpecialized AI personalities for different tasks (engineer, researcher, designer)
HooksEvent-driven automation that captures work and manages state
HistoryAutomatic documentation system (UOCS) that captures everything

Instead of cramming everything into massive prompts, PAI organizes knowledge into a hierarchical structure:

  • Projects: Active work with context
  • Methodologies: How you approach problems
  • Philosophy: Your principles and values
  • Tools: Technical capabilities
  • Tasks: Specific actions and workflows

Each directory contains specialized knowledge loaded only when needed.

PAI includes native integration with Fabric patterns—248+ AI patterns for content analysis and generation:

  • extract_wisdom: Extract key insights from content
  • summarize: Create concise summaries
  • threat_modeling: Security analysis workflows
  • And 245+ more patterns

Patterns run directly in Claude’s context using your subscription’s model, with full conversation history access.

PAI is built on 13 foundational principles:

  1. Clear Thinking + Prompting is King - Quality outcomes depend on quality thinking
  2. Scaffolding > Model - System architecture matters more than AI model power
  3. As Deterministic as Possible - Same input → Same output
  4. Code Before Prompts - Write code to solve problems, prompts to orchestrate
  5. Spec / Test / Evals First - Define expected behavior before implementation
  6. UNIX Philosophy - Do one thing well, compose tools through standard interfaces
  7. ENG / SRE Principles - Apply software engineering rigor to AI systems
  8. CLI as Interface - Every operation accessible via command line
  9. Goal → Code → CLI → Prompts → Agents - Proper development pipeline
  10. Meta / Self Update System - Systems that improve themselves
  11. Custom Skill Management - Skills as organizational units
  12. Custom History System - Automatic capture of valuable work
  13. Custom Agent Personalities - Specialized agents for different tasks
Terminal window
# 1. Clone PAI
git clone https://github.com/danielmiessler/PAI.git ~/PAI
# 2. Create Symlink
[ -d ~/.claude ] && mv ~/.claude ~/.claude.backup
ln -s ~/PAI/.claude ~/.claude
# 3. Run Setup Wizard
~/.claude/Tools/setup/bootstrap.sh
# 4. Configure API Keys
cp ~/.claude/.env.example ~/.claude/.env
nano ~/.claude/.env
# 5. Start Claude Code
source ~/.zshrc
claude
Terminal window
# Same steps as macOS, but source ~/.bashrc instead
source ~/.bashrc
claude
Terminal window
# Clone and create symlink
git clone https://github.com/danielmiessler/PAI.git $env:USERPROFILE\PAI
New-Item -ItemType SymbolicLink -Path "$env:USERPROFILE\.claude" -Target "$env:USERPROFILE\PAI\.claude"
# Run setup and configure
& "$env:USERPROFILE\.claude\tools\setup\bootstrap.ps1"
Copy-Item "$env:USERPROFILE\.claude\.env.example" "$env:USERPROFILE\.claude\.env"

Build the scaffolding that makes AI reliable before adding complexity. Following Miessler’s “solve once, reuse forever” philosophy, each component becomes reusable.

Every time you solve a problem, turn it into a reusable component:

  • Commands for specific workflows (write-blog-post, analyze-security)
  • Fabric patterns for content analysis and generation
  • Skills for domain expertise

The History System solves context loss between sessions. Everything gets automatically documented:

  • Work artifacts and decisions
  • Patterns and approaches used
  • Lessons learned

PAI is fully platform-agnostic—your AI identity, your system:

  • Configure your DA (Digital Assistant) name
  • Set your preferences and principles
  • Define your working style
  • Threat modeling with domain context
  • Vulnerability analysis workflows
  • Security report generation
  • Blog post writing with your voice
  • Research synthesis and summaries
  • Documentation generation
  • Code review with your standards
  • Architecture decision documentation
  • Project scaffolding
  • Research capture and organization
  • Learning documentation
  • Decision journaling
CategoryChoice
RuntimeBun (NOT Node.js)
LanguageTypeScript (NOT Python)
Package ManagerBun
FormatMarkdown
TestingVitest
VoiceElevenLabs TTS
  • Observability Dashboard: Real-time agent monitoring with live charts
  • Genericized Identity: Configure your DA name across the entire system
  • Platform-Agnostic Configuration: Clear separation of identity/paths and API keys
  • Native Fabric Patterns: 248 patterns run directly in Claude’s context

No! PAI is designed to give regular people access to sophisticated AI infrastructure. While technical knowledge helps, the goal is human flourishing, not just developer productivity.

Q: Can I use PAI with models other than Claude?

Section titled “Q: Can I use PAI with models other than Claude?”

Yes. While currently built on Claude Code, PAI’s architecture is platform-independent. The skills, workflows, and patterns can migrate to other AI platforms.

Q: How does PAI differ from just using Claude Code?

Section titled “Q: How does PAI differ from just using Claude Code?”

PAI adds structure, history, skills, and patterns on top of Claude Code. It’s not a different AI—it’s a framework that makes Claude Code work specifically for you.

Yes, PAI is open-source under MIT license. You’ll need a Claude subscription for the underlying AI capabilities.

FeaturePAIPlain Claude CodeCustom GPTs
Skills System✅ 65+ skillsLimited
History Persistence✅ Automatic
Native Fabric✅ 248 patterns
Self-Updating
Open Source✅ MITN/A
Platform Agnostic

Personal AI Infrastructure represents a paradigm shift in how we think about AI assistance. Instead of relying on generic chatbots or corporate AI systems, PAI empowers individuals to build AI infrastructure that:

  • Knows your context: Your goals, preferences, and working style
  • Learns over time: History compounds, patterns emerge
  • Serves your interests: Not engagement metrics or corporate profits
  • Remains yours: Open-source, portable, and customizable

As Daniel Miessler points out, the real power of AI infrastructure lies not in model intelligence but in orchestration. The magic happens when you create a system that knows you, adapts to your needs, and works autonomously on your behalf.

Start clean. Start small. Build the AI infrastructure you need.

SkillsMP: The Open Marketplace for AI Agent Skills

SkillsMP: The Open Marketplace for AI Agent Skills

Section titled “SkillsMP: The Open Marketplace for AI Agent Skills”

AI coding assistants have become indispensable tools for developers, but their capabilities are often limited to what comes built-in. SkillsMP changes this by providing an open marketplace where developers can discover, install, and share skills across multiple AI platforms.

SkillsMP is an open-source marketplace hosting over 31,000 agent skills that work seamlessly with the most popular AI coding assistants:

  • Claude Code - Anthropic’s official CLI tool
  • Codex CLI - OpenAI’s command-line interface
  • ChatGPT - The world’s most popular AI assistant

All skills use the unified SKILL.md format, ensuring compatibility across platforms and making it easy to share capabilities between different AI tools.

The SKILL.md format is the foundation of the agent skills ecosystem. It defines modular capabilities through:

  • Instructions - Clear guidance for the AI on what the skill does and how to use it
  • Scripts (optional) - Supporting code that extends functionality
  • Templates (optional) - Pre-built structures for common outputs

Skills are model-invoked, not user-invoked. This means the AI assistant decides when to activate a skill based on the context of your request, rather than requiring explicit commands.

---
name: my-skill
description: What this skill does and when to use it
---
# Instructions
When the user asks for X, follow these steps...

Different AI tools have their own skill directories:

ToolPersonal SkillsProject Skills
Claude Code~/.claude/skills/.claude/skills/
Codex CLI~/.codex/skills/.codex/skills/
ChatGPTVia plugin systemVia plugin system

SkillsMP organizes its vast library into 13 categories:

  1. Tools - General productivity enhancers
  2. Development - Code generation and refactoring
  3. Data & AI - Data analysis and ML utilities
  4. Business - Business process automation
  5. DevOps - Infrastructure and deployment
  6. Testing & Security - QA and security scanning
  7. Documentation - Docs generation and maintenance
  8. Content & Media - Content creation tools
  9. Lifestyle - Personal productivity
  10. Research - Information gathering
  11. Databases - Database operations
  12. Blockchain - Web3 and crypto tools

SkillsMP maintains quality through:

  • Minimum 2-star filter - Only GitHub repos with community validation
  • Open-source requirement - All skills are publicly auditable
  • User review recommended - Always review code before installation

Visit skillsmp.com to browse the marketplace. You can:

  • Search by keyword
  • Filter by category
  • Sort by popularity or recency
  • View skill documentation

For Claude Code, installation is straightforward:

Terminal window
# Install a skill from the marketplace
curl -O https://skillsmp.com/skills/skill-name/SKILL.md
mv SKILL.md ~/.claude/skills/skill-name/

Many skills also support one-command installation via their marketplace.json configuration.

Claude Code supports running multiple skills simultaneously. The AI intelligently selects which skills to activate based on context, enabling complex workflows that combine several capabilities.

Want to contribute to the marketplace? Creating a skill requires just a SKILL.md file:

---
name: my-custom-skill
description: A brief description of what this skill does
author: your-github-username
version: 1.0.0
---
# My Custom Skill
## When to Use
Use this skill when the user requests...
## Instructions
1. First, do this...
2. Then, do that...
3. Finally, complete with...
## Examples
### Example 1
User: "Help me with X"
Response: [How to handle this request]
  1. Create a GitHub repository with your skill
  2. Add a marketplace.json for easy installation
  3. Submit to SkillsMP for indexing

Important: SkillsMP is an independent community project. It is not affiliated with Anthropic or OpenAI.

For official skill resources:

  1. Review before installing - Always check the source code
  2. Start with popular skills - Higher stars indicate community trust
  3. Keep skills updated - Check for updates regularly
  4. Report issues - Help improve the ecosystem
  1. Write clear descriptions - Help users understand when to use your skill
  2. Include examples - Show concrete use cases
  3. Document thoroughly - Explain all features and limitations
  4. Test across platforms - Ensure compatibility

The standardization around SKILL.md represents a significant shift in how we extend AI capabilities. As more developers create and share skills:

  • Specialization increases - Skills become more focused and powerful
  • Quality improves - Community curation drives excellence
  • Adoption grows - Easy installation removes barriers
  • Innovation accelerates - Building on others’ work speeds development

SkillsMP democratizes access to AI agent capabilities by providing:

  • 31,000+ ready-to-use skills across 13 categories
  • Cross-platform compatibility via the SKILL.md standard
  • Open-source transparency with community quality control
  • Easy installation for all major AI coding assistants

Whether you’re looking to enhance your AI coding workflow or contribute your own skills to the community, SkillsMP provides the platform to make it happen.

Agent Skills for Context Engineering: Build Production-Grade AI Agent Systems

Agent Skills for Context Engineering: Build Production-Grade AI Agent Systems

Section titled “Agent Skills for Context Engineering: Build Production-Grade AI Agent Systems”

In the rapidly evolving landscape of AI development, context engineering has emerged as one of the most critical disciplines for building effective agent systems. Unlike prompt engineering, which focuses on crafting effective instructions, context engineering addresses the holistic curation of all information entering a model’s limited attention window.

Agent Skills for Context Engineering by Murat Can Koylan is a comprehensive, open-source collection designed to teach the art and science of curating context to maximize agent effectiveness across any platform.

Context engineering is the discipline of managing the language model’s context window. The fundamental challenge is that context windows are constrained not by raw token capacity but by attention mechanics.

As context length increases, models exhibit predictable degradation patterns:

  • Lost-in-the-Middle Phenomenon - Information in the middle of long contexts gets less attention
  • U-Shaped Attention Curves - Models focus more on beginning and end of context
  • Attention Scarcity - Limited “attention budget” must be allocated wisely

Effective context engineering means finding the smallest possible set of high-signal tokens that maximize the likelihood of desired outcomes. This requires understanding what context is, how it degrades, and how to optimize it.

The collection is organized into three tiers of increasing complexity.

These skills establish the foundational understanding required for all subsequent context engineering work.

SkillDescription
context-fundamentalsUnderstand what context is, why it matters, and the anatomy of context in agent systems
context-degradationRecognize patterns of context failure: lost-in-middle, poisoning, distraction, and clash
context-compressionDesign and evaluate compression strategies for long-running sessions

These skills cover the patterns and structures for building effective agent systems.

SkillDescription
multi-agent-patternsMaster orchestrator, peer-to-peer, and hierarchical multi-agent architectures
memory-systemsDesign short-term, long-term, and graph-based memory architectures
tool-designBuild tools that agents can use effectively

These skills address the ongoing operation and optimization of agent systems.

SkillDescription
context-optimizationApply compaction, masking, and caching strategies
evaluationBuild evaluation frameworks for agent systems

Understanding the anatomy of context in agent systems is essential:

Components of Context:

  • System prompts
  • Tool definitions
  • Retrieved documents
  • Message history
  • Tool outputs

Each component competes for limited attention. Effective agents prioritize high-signal information and compress or eliminate low-signal content.

Recognizing failure patterns helps prevent them:

Lost-in-Middle: Critical information placed in the middle of long contexts receives less model attention.

Context Poisoning: Bad or conflicting information corrupts the model’s understanding.

Context Distraction: Irrelevant information diverts attention from important content.

Context Clash: Contradictory instructions or data create confusion.

Three primary architectures for multi-agent systems:

Orchestrator Pattern: A central agent coordinates specialized sub-agents, managing task delegation and result aggregation.

[Orchestrator]
/|\
/ | \
/ | \
[Agent][Agent][Agent]

Peer-to-Peer Pattern: Agents communicate directly without central coordination, suitable for collaborative tasks.

Hierarchical Pattern: Layered agent structures where higher-level agents manage groups of lower-level agents.

Effective agents require multiple memory types:

Short-term Memory:

  • Recent conversation context
  • Current task state
  • Immediate working memory

Long-term Memory:

  • Persistent knowledge stores
  • User preferences
  • Historical patterns

Graph-based Memory:

  • Relationship maps between concepts
  • Entity connections
  • Semantic networks

Install skills by referencing the repository or copying skill folders into your configured skills directory:

Terminal window
# Clone the repository
git clone https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering.git
# Copy skills to your project
cp -r Agent-Skills-for-Context-Engineering/skills/* ./skills/

When working on context engineering tasks, activate relevant skills to load their instructions.

Copy skill content into .cursorrules or create project-specific rules files:

Terminal window
# Create rules file
cat skills/context-fundamentals/SKILL.md >> .cursorrules

The skills provide the context and guidelines that Cursor’s agent needs for effective context engineering.

Extract the principles and patterns from any skill and implement them in your agent framework. The skills are deliberately platform-agnostic, making them applicable to any LLM-based system.

When developing agents for real-world deployment:

  • Start with fundamentals - Understand context anatomy before optimization
  • Design memory early - Memory architecture affects all downstream decisions
  • Plan for degradation - Build in monitoring and recovery mechanisms
  • Test at scale - Evaluation frameworks catch issues before production

For teams with existing agent systems:

  • Diagnose context issues - Use degradation patterns to identify problems
  • Apply compression strategies - Reduce token usage without losing signal
  • Implement caching - Avoid redundant context loading
  • Add instrumentation - Build visibility into context usage

When building systems with multiple coordinating agents:

  • Choose the right pattern - Orchestrator vs peer-to-peer vs hierarchical
  • Design communication protocols - How agents share context
  • Manage shared memory - Coordination without conflicts
  • Handle failures gracefully - Recovery when agents fail

For learning about agent development:

  • Progressive disclosure - Skills build on each other logically
  • Practical examples - Python pseudocode demonstrates concepts
  • Platform-agnostic - Learn principles, not vendor lock-in
  • Open source - Study, modify, and contribute
1. Load context-fundamentals skill
2. Review overnight agent logs for degradation patterns
3. Identify context bottlenecks
4. Plan optimization tasks
5. Update monitoring dashboards
1. Activate multi-agent-patterns skill
2. Design agent architecture diagram
3. Define context boundaries for each agent
4. Implement memory systems
5. Build evaluation framework
6. Test with context-degradation checks
1. Load context-degradation skill
2. Identify symptoms (lost-in-middle? poisoning?)
3. Trace context flow through system
4. Apply appropriate fix strategy
5. Validate with evaluation skill

The collection follows three key principles:

1. Progressive Disclosure

Each skill is structured for efficient context use. At startup, agents load only skill names and descriptions. Full content loads only when a skill is activated for relevant tasks.

2. Platform Agnosticism

These skills focus on transferable principles rather than vendor-specific implementations. The patterns work across Claude Code, Cursor, and any agent platform that supports skills or allows custom instructions.

3. Conceptual Foundation with Practical Examples

Scripts and examples demonstrate concepts using Python pseudocode that works across environments without requiring specific dependency installations.

Each skill follows the Agent Skills specification:

skill-name/
├── SKILL.md # Required: instructions + metadata
├── scripts/ # Optional: executable code
└── references/ # Optional: additional docs

When contributing new skills:

  1. Follow the skill template structure
  2. Provide clear, actionable instructions
  3. Include working examples where appropriate
  4. Document trade-offs and potential issues
  5. Keep SKILL.md under 500 lines for optimal performance
FeatureAgent SkillsCustom RulesFramework Docs
Platform SupportAnyPlatform-specificFramework-specific
FocusContext engineeringGeneralFramework usage
StructureStandardizedVariableVariable
Progressive LoadingYesNoNo
Open SourceMITVariesVaries
ExamplesPython pseudocodeVariesFramework-specific

vs. Custom Rules:

  • Standardized structure enables sharing and reuse
  • Progressive disclosure reduces initial context cost
  • Community contributions expand coverage

vs. Framework Documentation:

  • Focuses on principles, not implementation details
  • Transferable across platforms
  • Practical orientation for production systems

Q: Do these skills work with any LLM? A: Yes, the principles are LLM-agnostic. Examples use Python pseudocode that can be adapted to any environment.

Q: How do I know which skill to use? A: Start with fundamentals, then move to architectural skills for design decisions, and operational skills for optimization.

Q: Can I contribute new skills? A: Absolutely! Follow the template structure and submit pull requests. Community contributions are welcome.

Q: Are there costs associated with using these skills? A: No, the repository is MIT licensed. However, the LLMs you use with these skills may have associated costs.

Q: How do skills handle context limits? A: Progressive disclosure means only relevant content loads. Each skill is designed to stay under 500 lines.

Skills not loading:

  • Ensure skill folder structure is correct
  • Check that SKILL.md exists in skill directory
  • Verify file permissions

Poor agent performance:

  • Review context-degradation skill for diagnostic patterns
  • Check if context window is being exceeded
  • Evaluate information signal-to-noise ratio

Multi-agent coordination issues:

  • Review multi-agent-patterns skill
  • Check message passing protocols
  • Verify shared memory access patterns

Context engineering is becoming as fundamental to AI development as software engineering principles are to traditional development. Agent Skills for Context Engineering provides a structured, open, and platform-agnostic foundation for mastering this critical discipline.

Whether you’re building your first agent or optimizing production multi-agent systems, these skills offer the conceptual foundation and practical guidance needed for success. The progressive disclosure design means you can start small and expand as needed, while the platform-agnostic approach ensures your learning transfers across tools and frameworks.

The AI agent ecosystem is maturing rapidly, and context engineering will be a key differentiator between agents that work and agents that work well. Start with the fundamentals, understand degradation patterns, and build systems that manage context effectively.


Explore the full collection at Agent Skills for Context Engineering and join the community building better agent systems.

Enabling Claude Code to Work More Autonomously: Complete Guide to VS Code Extension, Checkpoints & Agent SDK

Anthropic has released several major upgrades to Claude Code that fundamentally transform how developers interact with AI-powered development tools. These updates include a native VS Code extension, version 2.0 of the terminal interface, and most notably, checkpoints for autonomous operation. Powered by Claude Sonnet 4.5, Claude Code now handles longer, more complex development tasks with unprecedented confidence and control.

This article provides a comprehensive guide to these new autonomy features, covering installation, configuration, best practices, and real-world workflow examples.

The native VS Code extension brings Claude Code directly into your IDE with several powerful capabilities:

  • Real-time Change Visualization: See Claude’s changes in real-time through a dedicated sidebar panel with inline diffs
  • Graphical Experience: A richer, more visual Claude Code experience for developers who prefer IDEs over terminals
  • Seamless Integration: Works within your existing VS Code workflow without context switching

Installation: Download from the VS Code Extension Marketplace

The refreshed terminal interface includes:

  • Improved Status Visibility: Better visual feedback on Claude’s current operations
  • Searchable Prompt History: Use Ctrl+r to search and reuse previous prompts
  • Streamlined UX: Easier navigation and command execution

The checkpoint system is a game-changer for autonomous development:

  • Automatic State Saving: Automatically saves your code state before each change
  • Instant Rewind: Tap Esc twice or use /rewind command to return to previous versions
  • Selective Restoration: Choose to restore code, conversation, or both
  • Multi-level Undo: Not just one level—checkpoints are kept for each change

Best Practice: Use checkpoints in combination with version control (git) for maximum safety.

Subagents delegate specialized tasks, enabling parallel development workflows:

# Example: Main agent spawns specialized subagents
from claude_agent_sdk import query, ClaudeAgentOptions, AgentDefinition
async for message in query(
prompt="Build a full-stack feature with tests",
options=ClaudeAgentOptions(
allowed_tools=["Read", "Write", "Edit", "Bash", "Task"],
agents={
"backend-dev": AgentDefinition(
description="Backend API developer",
prompt="Build REST APIs following best practices",
tools=["Read", "Write", "Edit", "Bash"]
),
"frontend-dev": AgentDefinition(
description="Frontend developer",
prompt="Build React components with TypeScript",
tools=["Read", "Write", "Edit", "Bash"]
),
"test-engineer": AgentDefinition(
description="Test automation engineer",
prompt="Write comprehensive test coverage",
tools=["Read", "Write", "Bash"]
)
}
)
):
print(message)

Hooks trigger actions at specific points in the development lifecycle:

  • PostToolUse: Run tests after code changes
  • PreToolUse: Lint before commits
  • SessionStart/End: Initialize or cleanup resources
  • UserPromptSubmit: Validate or transform user input
# Example: Automatic test running after file edits
async def run_tests_after_edit(input_data, tool_use_id, context):
file_path = input_data.get('tool_input', {}).get('file_path', '')
if file_path.endswith('.py'):
# Run pytest for Python files
return {"command": "pytest", "args": [file_path]}
return {}
options = ClaudeAgentOptions(
hooks={
"PostToolUse": [HookMatcher(matcher="Edit", hooks=[run_tests_after_edit])]
}
)

Keep long-running processes active without blocking progress:

  • Dev servers running continuously
  • Build watchers monitoring changes
  • Database migrations running in background
  • Compilation tasks executing asynchronously
  • Node.js: Version 18 or higher
  • Python: Version 3.10 or higher (for Python SDK)
  • Operating System: macOS, Linux, or Windows with WSL

macOS/Linux/WSL:

Terminal window
curl -fsSL https://claude.ai/install.sh | bash

Homebrew (macOS):

Terminal window
brew install --cask claude-code

npm:

Terminal window
npm install -g @anthropic-ai/claude-code

TypeScript/Node.js:

Terminal window
npm install @anthropic-ai/claude-agent-sdk

Python:

Terminal window
pip install claude-agent-sdk
Terminal window
export ANTHROPIC_API_KEY=your-api-key

Get your key from the Anthropic Console.

Alternative Providers:

  • Amazon Bedrock: CLAUDE_CODE_USE_BEDROCK=1
  • Google Vertex AI: CLAUDE_CODE_USE_VERTEX=1
  • Microsoft Foundry: CLAUDE_CODE_USE_FOUNDRY=1

When refactoring large codebases, checkpoints + subagents work together:

  1. Create a checkpoint before starting
  2. Spawn subagents for different modules
  3. Each subagent refactors its assigned area
  4. Hooks run tests after each change
  5. If tests fail, rewind to checkpoint
Terminal window
# Start Claude Code with test-driven development workflow
claude --with-hooks "run tests after each edit"
# Claude will:
# 1. Write failing tests first
# 2. Implement code to pass tests
# 3. Automatically run tests after each edit
# 4. Create checkpoints at each green state
# Full-stack API development with parallel agents
agents = {
"api-designer": AgentDefinition(
description="OpenAPI specification writer",
prompt="Design RESTful APIs following OpenAPI 3.0",
tools=["Read", "Write"]
),
"api-implementer": AgentDefinition(
description="Backend implementation",
prompt="Implement FastAPI endpoints from spec",
tools=["Read", "Write", "Edit", "Bash"]
),
"api-tester": AgentDefinition(
description="API test automation",
prompt="Write pytest tests for all endpoints",
tools=["Read", "Write", "Bash"]
)
}
Terminal window
# Review overnight PRs with Claude
claude "Review all open PRs, summarize changes, identify potential issues"
Terminal window
# Use checkpoints for safe debugging
claude "Debug the auth module - create checkpoints before each change"
Terminal window
# Automated code cleanup with hooks
claude "Clean up TODO comments, format code, run linter" --auto-commit
  1. Checkpoints vs Git: Checkpoints only track Claude’s edits, not user edits or bash commands. Always use git for version control.

  2. Subagent Permissions: Be careful about which tools you grant to subagents. Use principle of least privilege.

  3. Background Tasks: Monitor background tasks to prevent resource exhaustion.

Q: Can I use checkpoints without git? A: Yes, but it’s not recommended. Checkpoints supplement, not replace, version control.

Q: How many subagents can run in parallel? A: There’s no hard limit, but resource constraints apply. Start with 2-3 and scale based on your system.

Q: Do hooks slow down development? A: Minimal overhead. Hooks run asynchronously where possible.

Q: Can I use Claude Code with local models? A: The Agent SDK supports Bedrock, Vertex AI, and Foundry. Local model support depends on provider compatibility.

IssueSolution
Checkpoint not savingCheck disk space and permissions
Subagent timeoutIncrease timeout in options or simplify task
Hook not triggeringVerify matcher regex matches tool name
API key invalidRegenerate key from Console
FeatureClaude CodeGitHub CopilotCursorCody
Checkpoints✅ Built-in
Subagents✅ Native
Hooks✅ ExtensiveLimitedLimited
VS Code Extension✅ Beta✅ StableN/A
Terminal CLI✅ Full
Agent SDK✅ Python/TS
  • Claude Code: Best for autonomous, complex development with full control
  • GitHub Copilot: Best for inline code suggestions
  • Cursor: Best for AI-first IDE experience
  • Cody: Best for enterprise code understanding

Claude Code’s autonomy upgrades represent a significant leap in AI-assisted development. The combination of checkpoints, subagents, hooks, and background tasks creates a development environment where you can confidently delegate complex tasks while maintaining full control. Whether you’re refactoring a legacy codebase, building new features, or exploring experimental approaches, these tools provide the safety net and parallel processing power to work more efficiently than ever before.

Start with the VS Code extension for a gentler learning curve, then graduate to the Agent SDK for building production-ready autonomous agents tailored to your specific workflows.

Claude Code System Prompts Revealed: Inside the AI That Powers Your Coding

Discover the Hidden Architecture Behind Anthropic’s AI Coding Assistant

Claude Code System Prompts


Ever wondered what makes Claude Code tick? Thanks to the open-source community, specifically the Piebald-AI/claude-code-system-prompts repository, we now have unprecedented visibility into the intricate system prompts that power one of the most popular AI coding assistants on the market.

This repository, maintained by the team behind Piebald, provides a comprehensive breakdown of all Claude Code’s various system prompts, updated with each new version. As of Claude Code v2.0.75 (December 20th, 2025), it covers 56 versions of changelog since v2.0.14.


Why Claude Code Has Multiple System Prompts

Section titled “Why Claude Code Has Multiple System Prompts”

Claude Code doesn’t just have one single string for its system prompt. Instead, there are multiple components working together:

Component TypeDescription
Conditional PromptsLarge portions added depending on environment and configs
Tool DescriptionsBuiltin tools like Write, Bash, and TodoWrite
Agent PromptsSeparate system prompts for Explore, Plan, and Task agents
Utility FunctionsAI-powered features like conversation compaction, CLAUDE.md generation

The result is 40+ strings that are constantly changing and moving within a very large minified JS file.


The core system prompt defines Claude Code’s fundamental behavior:

Communication Style:

  • Responses should be “short and concise” for command-line display
  • Uses GitHub-flavored markdown formatted for monospace fonts
  • Avoids emojis unless explicitly requested
  • Tools are for task completion only, not user communication

Technical Approach:

  • Prioritizes technical accuracy and truthfulness
  • Provides direct, objective technical info
  • Reads files before proposing modifications
  • Avoids over-engineering and unnecessary abstractions
AgentTokensPurpose
Explore516System prompt for the Explore subagent
Plan Mode (Enhanced)633Enhanced prompt for the Plan subagent
Task Tool294System prompt for Task tool spawned subagents
AgentTokensPurpose
Agent Creation Architect1,111Creating custom AI agents with detailed specifications
CLAUDE.md Creation384Analyzing codebases and creating CLAUDE.md files
Status Line Setup1,310Configuring status line display
CommandTokensPurpose
/pr-comments402Fetching and displaying GitHub PR comments
/review-pr243Reviewing GitHub pull requests
/security-review2,610Comprehensive security review for code changes
UtilityTokensPurpose
Bash Command Prefix Detection835Detecting command prefixes and injection
Conversation Summarization1,121+Creating detailed conversation summaries
Claude Guide Agent763Helping users understand Claude Code
Session Title Generation333Generating titles and git branch names
WebFetch Summarizer185Summarizing verbose web fetch output

Claude Code’s builtin tools have their own detailed descriptions:

ToolTokensDescription
Bash1,074Run shell commands with safety guidelines
TodoWrite2,167Task list management with best practices
Task1,214Launching specialized sub-agents
EnterPlanMode970Entering plan mode for implementation design
ReadFile439Reading files with multimodal support
Edit278Exact string replacements in files
Write159Creating/overwriting files
Grep300Content search using ripgrep

The system prompts are constantly evolving. Here are key recent changes:

  • Streamlined task tool instructions
  • Removed directive against using colons before tool calls
  • New “Session Search Assistant” agent for finding relevant sessions
  • Removed delegate mode restrictions
  • Added “Prompt Suggestion Generator v2” with improved intent prediction
  • Merged slash command functionality into the Skill tool
  • Expanded LSP capabilities with call hierarchy operations
  • Introduced browser automation support via new Computer tool
  • Chrome-based task execution enabled
  • Major planning philosophy shift: EnterPlanMode rewritten to encourage proactive planning for non-trivial tasks

Understanding these prompts helps you:

  1. Work more effectively with Claude Code - Knowing its priorities and constraints
  2. Craft better prompts - Align your requests with Claude Code’s design
  3. Debug unexpected behavior - Understand why certain responses occur

This transparency offers:

  1. Learning opportunities - Study how production AI systems are prompted
  2. Best practices - See how Anthropic structures complex multi-agent systems
  3. Research material - Compare prompting strategies across tools

Want to customize Claude Code’s system prompts? The Piebald team also created tweakcc, which lets you:

  • Customize individual pieces of the system prompt as markdown files
  • Patch your npm-based or native Claude Code installation
  • Manage conflicts when both you and Anthropic modify the same prompt file

Piebald is described as “the ultimate agentic AI developer experience.” It supports:

  • Multi-provider APIs: OpenAI-compatible, Anthropic-compatible, or Google-compatible
  • Credential imports: From Claude Code, Gemini CLI, and Codex CLI
  • Full customization: Prompts, model settings, and reusable profiles

The Piebald-AI/claude-code-system-prompts repository provides unprecedented insight into how Claude Code works internally:

  • 40+ prompt strings working together
  • Multiple agent types for different tasks
  • Detailed tool descriptions guiding behavior
  • Constant evolution across 56+ versions

This transparency benefits the entire AI development community by showing how production AI coding assistants are architected.


Sources:


Have you explored Claude Code’s system prompts? What insights have you discovered? Share in the comments!

Hugging Face Skills: Fine-Tune Any Open-Source LLM with Natural Language

Turn Conversations Into Fine-Tuned Models — No ML Expertise Required

Hugging Face Skills


Hugging Face Skills is a revolutionary system that enables AI coding agents like Claude Code, OpenAI Codex, and Google Gemini CLI to fine-tune open-source language models end-to-end through natural language conversations.

Instead of writing complex training scripts, configuring GPU resources, and managing deployment pipelines manually, you simply describe what you want in plain English:

Fine-tune Qwen3-0.6B on my customer support dataset for 3 epochs.

The AI agent handles everything else: data validation, hardware selection, script generation, job submission, progress monitoring, and model publishing.


CapabilityDescription
Data ValidationAutomatically checks dataset format compatibility before training
Hardware SelectionIntelligently picks the right GPU based on model size and budget
Script GenerationCreates production-ready training scripts with TRL library
Job SubmissionSubmits training jobs to Hugging Face cloud GPUs
Real-time MonitoringTracks progress via Trackio dashboard
Model PublishingPushes finished models to Hugging Face Hub
GGUF ConversionConverts models for local deployment with llama.cpp/Ollama
MethodBest ForExample Dataset
SFT (Supervised Fine-Tuning)Quality behavior examplesCustomer support conversations
DPO (Direct Preference Optimization)Preference-annotated dataChosen/rejected response pairs
GRPO (Group Relative Policy Optimization)Verifiable success criteriaMath problems, coding tasks
  • Anthropic Claude Code — Full integration via MCP protocol
  • OpenAI Codex — Uses AGENTS.md for instruction loading
  • Google Gemini CLI — Extensions-based integration
  • Coming Soon: Cursor, Windsurf, Continue

Prerequisites, Installation and Configuration

Section titled “Prerequisites, Installation and Configuration”
  • Hugging Face Account with Pro or Team/Enterprise plan (Jobs require paid plan)
  • Write-Access Token from huggingface.co/settings/tokens
  • Coding Agent (Claude Code, Codex, or Gemini CLI)
Terminal window
# Step 1: Register the Hugging Face Skills marketplace
/plugin marketplace add huggingface/skills
# Step 2: Install the LLM trainer skill
/plugin install hf-llm-trainer@huggingface-skills

Alternative: MCP-based Installation

Terminal window
# Add via MCP transport
claude mcp add --transport http hf-skills \
https://huggingface.co/mcp?bouquet=skills \
--header "Authorization: Bearer $HF_TOKEN"

Codex auto-identifies skills via the AGENTS.md file:

Terminal window
# Verify installation
codex --ask-for-approval never "Summarize the current instructions."
Terminal window
# Option 1: Install from GitHub
gemini extensions install https://github.com/huggingface/skills.git --consent
# Option 2: Local installation
gemini extensions install . --consent
Terminal window
# Interactive login (recommended)
hf auth login
# Or set environment variable
export HF_TOKEN=hf_your_write_access_token_here

Scenario 1: Customer Support Bot Fine-Tuning

Section titled “Scenario 1: Customer Support Bot Fine-Tuning”
Fine-tune Qwen3-1.7B on my-org/support-conversations
for customer service responses. Use SFT for 3 epochs.

Expected Workflow:

  1. Agent validates dataset format (looks for “messages” column)
  2. Selects t4-medium hardware (~$0.75/hour)
  3. Configures training with appropriate batch size
  4. Submits job and provides monitoring link
  5. Pushes model to your-username/qwen-support-sft

Scenario 2: Code Assistant with Preference Learning

Section titled “Scenario 2: Code Assistant with Preference Learning”
Stage 1: SFT on code-examples dataset
Stage 2: DPO alignment using preference-data with
chosen/rejected columns

Multi-stage Pipeline:

  • First stage creates base capabilities
  • Second stage aligns with human preferences
  • Agent handles both stages automatically
Train a math reasoning model using GRPO on openai/gsm8k
based on Qwen3-0.6B. Use verifiable reward signals.

Best for:

  • Problems with correct/incorrect answers
  • Code generation with unit tests
  • Mathematical proofs
  1. Always Validate First

    Check if my-org/training-data works for SFT training.

    This costs pennies and prevents $30+ failures.

  2. Start with Demo Runs

    Do a quick test run on 100 examples of my dataset.
  3. Be Explicit for Production

    SFT Qwen-0.6B for production on the full dataset.
    Checkpoints every 500 steps, 3 epochs, cosine learning rate.
  4. Monitor in Real-Time

    How's my training job doing?

    Get live loss curves, learning rate, and ETA.


Model SizeRecommended GPUTraining TimeEst. CostNotes
<1Bt4-small<1 hour$1-2Demo/testing
1-3Bt4-medium / a10g-small2-3 hours$5-15Small production
3-7Ba10g-large (LoRA)4-8 hours$15-40Medium production
7B+Not supportedToo large for this tool

Note: Models above 3B automatically use LoRA (Low-Rank Adaptation) to fit in memory while maintaining quality.


Q: What’s the minimum cost to try this?

A: A demo run on 100 examples with t4-small costs approximately $0.30-0.50.

Q: Can I train models larger than 7B?

A: The current HF Skills system supports up to 7B. For larger models, use full Hugging Face infrastructure.

Q: Which dataset formats are supported?

A:

  • SFT: messages column with conversation format
  • DPO: chosen, rejected, and optionally prompt columns
  • GRPO: Dataset with verifiable correct answers

Q: How do I fix column name mismatches?

A: Ask the agent:

My DPO dataset uses 'good_response' and 'bad_response'
instead of 'chosen' and 'rejected'. How do I fix this?
IssueSolution
Out of MemoryAgent suggests batch size reduction or hardware upgrade
Dataset Format ErrorRun validation first; agent identifies mismatches
Training TimeoutAdjust epoch count or use checkpointing
Authentication FailedVerify HF_TOKEN has write permissions
  1. Use Trackio Dashboard — Real-time training visualization at huggingface.co/spaces/username/trackio
  2. Convert to GGUF — Deploy locally without internet dependency
  3. Checkpoint Regularly — Recover from interruptions without losing progress

Comparison with Similar Products and Services

Section titled “Comparison with Similar Products and Services”

Hugging Face Skills vs. Traditional Fine-Tuning

Section titled “Hugging Face Skills vs. Traditional Fine-Tuning”
AspectTraditionalHF Skills
Setup TimeHours to daysMinutes
ML Knowledge RequiredExtensiveNone
Hardware ManagementManualAutomated
Cost VisibilityAfter trainingBefore submission
MonitoringCustom setupBuilt-in Trackio
AgentIntegration MethodStrengths
Claude CodeMCP + PluginBest for complex multi-step workflows
OpenAI CodexAGENTS.mdStrong code generation
Gemini CLIExtensionsGoogle ecosystem integration
ToolFocusKey Difference
Hugging Face AutoTrainGUI-based trainingVisual interface, less conversational
AWS SageMakerEnterprise MLMore complex, broader scope
Google Vertex AICloud MLTightly coupled with GCP
Together AIInference + TrainingFocus on API-first approach

Why Choose HF Skills?

  • Natural language interface
  • No code required
  • Cost-effective for small-to-medium models
  • Seamless Hub integration


Hugging Face Skills represents a paradigm shift in how we approach model fine-tuning. By bridging the gap between natural language and machine learning infrastructure, it democratizes access to custom AI model creation.

Whether you’re a developer looking to create a specialized code assistant, a business building a customer support bot, or a researcher exploring new training methods, HF Skills provides an accessible, cost-effective, and powerful solution.

Get Started Today:

Terminal window
# Install the skill
/plugin marketplace add huggingface/skills
/plugin install hf-llm-trainer@huggingface-skills
# Authenticate
hf auth login
# Start training!
"Fine-tune Qwen3-0.6B on my dataset for instruction following."

The future of AI model training is conversational. Welcome to the age of Skills.


Last updated: December 21, 2025

n8n-skills: Build Flawless n8n Workflows with Claude Code

Transform Your n8n Workflow Development with AI-Powered Skills

n8n-skills Claude Code Integration


n8n-skills is a collection of 7 complementary Claude Code skills designed to teach AI assistants how to build production-ready n8n workflows using the n8n-mcp MCP server.

Created by Romuald Członkowski from AI Advisors, these skills solve the common challenges developers face when building n8n workflows programmatically.


Building n8n workflows programmatically can be challenging. Common issues include:

ChallengeHow n8n-skills Helps
Using MCP tools incorrectlyExpert guidance on tool selection
Validation error loopsValidation error interpretation and fixing
Unknown workflow patterns5 proven architectural patterns
Node misconfigurationOperation-aware node configuration
Expression syntax errorsCorrect {{}} patterns and variables

Teaches correct n8n expression syntax and common patterns.

Activates when: Writing expressions, using {{}} syntax, accessing $json/$node variables.

Key Features:

  • Core variables ($json, $node, $now, $env)
  • Critical gotcha: Webhook data is under $json.body
  • Common mistakes catalog with fixes
  • When NOT to use expressions (Code nodes!)

2. n8n MCP Tools Expert (HIGHEST PRIORITY)

Section titled “2. n8n MCP Tools Expert (HIGHEST PRIORITY)”

Expert guide for using n8n-mcp MCP tools effectively.

Key Features:

  • Tool selection guide (which tool for which task)
  • nodeType format differences (nodes-base.* vs n8n-nodes-base.*)
  • Validation profiles (minimal/runtime/ai-friendly/strict)
  • Smart parameters (branch=“true” for IF nodes)
  • Auto-sanitization system explained

Build workflows using 5 proven architectural patterns.

Key Features:

  • 5 proven patterns (webhook processing, HTTP API, database, AI, scheduled)
  • Workflow creation checklist
  • Real examples from 2,653+ n8n templates
  • Pattern selection guide

Interpret validation errors and guide fixing.

Key Features:

  • Validation loop workflow
  • Real error catalog
  • Auto-sanitization behavior explained
  • False positives guide

Operation-aware node configuration guidance.

Key Features:

  • Property dependency rules (e.g., sendBody → contentType)
  • Operation-specific requirements
  • AI connection types (8 types for AI Agent workflows)

Write effective JavaScript code in n8n Code nodes.

Key Features:

  • Data access patterns ($input.all(), $input.first(), $input.item)
  • Correct return format: [{json: {...}}]
  • Built-in functions ($helpers.httpRequest(), DateTime, $jmespath())
  • Top 5 error patterns with solutions (covering 62%+ of failures)
  • 10 production-tested patterns

Write Python code in n8n Code nodes with proper limitations awareness.

Key Features:

  • Important: Use JavaScript for 95% of use cases
  • Critical limitation: No external libraries (requests, pandas, numpy)
  • Standard library reference (json, datetime, re, etc.)
  • Workarounds for missing libraries

  1. n8n-mcp MCP server installed and configured (Installation Guide)
  2. Claude Code, Claude.ai, or Claude API access
  3. .mcp.json configured with n8n-mcp server
Section titled “Method 1: Plugin Installation (Recommended)”
Terminal window
# Install directly as a Claude Code plugin
/plugin install czlonkowski/n8n-skills
Terminal window
# Add as marketplace, then browse and install
/plugin marketplace add czlonkowski/n8n-skills
# Then browse available plugins
/plugin install
# Select "n8n-mcp-skills" from the list
Terminal window
# 1. Clone this repository
git clone https://github.com/czlonkowski/n8n-skills.git
# 2. Copy skills to your Claude Code skills directory
cp -r n8n-skills/skills/* ~/.claude/skills/
# 3. Reload Claude Code
# Skills will activate automatically

User: "Build and validate a webhook to Slack workflow"
Skills activated:
1. n8n Workflow Patterns → Identifies webhook processing pattern
2. n8n MCP Tools Expert → Searches for webhook and Slack nodes
3. n8n Node Configuration → Guides node setup
4. n8n Code JavaScript → Helps process webhook data
5. n8n Expression Syntax → Helps with data mapping
6. n8n Validation Expert → Validates the final workflow

Perfect for building intelligent automation with LangChain nodes:

  • AI connection types guidance
  • Memory and output parser configuration
  • Streaming mode constraints

Build reliable scheduled workflows:

  • Scheduled trigger configuration
  • Database integration patterns
  • Error handling best practices

Connect external services efficiently:

  • HTTP Request node configuration
  • Authentication patterns
  • Response handling

Always check n8n’s 2,709 workflow templates before building from scratch:

"Search templates for slack notification"
→ n8n MCP Tools Expert activates
→ Returns curated template options

Use the multi-level validation approach:

LevelProfileUse Case
1minimalQuick required fields check (<100ms)
2runtimeFull validation with fixes
3ai-friendlyBalanced for AI workflows
4strictComplete validation

Many n8n nodes have conditional properties:

// Example: HTTP Request node
{
sendBody: true, // Setting this...
contentType: "json" // ...requires this
}
// ✅ Correct
{{ $json.data.value }}
{{ $node["Previous Node"].json.result }}
// ❌ Common mistakes
{{ $json["body"]["data"] }} // In webhook, data is under $json.body!

A: Remember that webhook data is under $json.body, not directly in $json. This is the most common gotcha.

// ❌ Wrong
{{ $json.userId }}
// ✅ Correct
{{ $json.body.userId }}

Q: How do I choose between Code node JS vs Python?

Section titled “Q: How do I choose between Code node JS vs Python?”

A: Use JavaScript for 95% of use cases. Python has critical limitations:

  • No external libraries (requests, pandas, numpy)
  • Only standard library available

Q: Validation keeps failing with false positives

Section titled “Q: Validation keeps failing with false positives”

A: Use appropriate validation profiles:

  • minimal for quick checks during development
  • runtime for production-ready validation
  • Check the auto-sanitization behavior

A: Follow this order:

  1. search_templates - Check if templates exist
  2. search_nodes - Find required nodes
  3. get_node - Get configuration details
  4. validate_node - Validate your config
  5. validate_workflow - Final check

AspectWith n8n-skillsWithout
Learning curveGuided by AISelf-discovery
Error handlingProactive patternsTrial and error
Best practicesBuilt-inResearch required
ValidationMulti-level automatedManual testing
Featuren8nZapierMake
Self-hosted
Code nodes✅ Full JS/PythonLimitedLimited
AI integration✅ LangChainBasicBasic
Open source
MCP support✅ via n8n-mcp
ToolPurpose
n8n-mcpMCP server for n8n (required)
n8nWorkflow automation platform
Claude CodeAI coding assistant

  • 7 complementary skills that work together
  • 525+ n8n nodes supported
  • 2,653+ workflow templates for examples
  • 10 production-tested Code node patterns
  • Comprehensive error catalogs and troubleshooting guides

n8n-skills transforms the way you build n8n workflows with Claude Code:

  1. Automatic activation - Skills trigger when relevant queries are detected
  2. Composable design - All 7 skills work together seamlessly
  3. Production-ready patterns - Based on real-world usage
  4. Validation first - Catch errors before deployment

Whether you’re building simple webhook integrations or complex AI agent workflows, n8n-skills provides the guidance you need to build flawless automation.


Reference Links:


Ready to supercharge your n8n workflow development? Install n8n-skills today and let AI guide your automation journey!

BMAD Installation & Configuration Guide: Best Practices for Project-Level Setup

BMAD (Build More, Architect Dreams) is an AI-driven agile development methodology framework that integrates multiple AI Agents, workflows, and modules. It supports 18+ IDEs including Claude Code, Codex, and Cursor. This guide walks you through the complete installation and configuration process for BMAD v6.0.0-alpha.


Key Recommendation: Install BMAD in your project directory, NOT in your user home directory.

Benefits:

  • Isolation: Each project has independent BMAD configuration
  • Version Control: Project-level config can be tracked with Git
  • Team Collaboration: Team members get identical configs when cloning
  • Multi-Project Support: Different projects can use different BMAD versions

Post-installation directory structure:

Project Directory Structure

The .bmad configuration directory contains these submodules:

BMAD Directory Structure


Ensure you have:

  • Node.js (v18+ recommended)
  • Bun or npm/npx
  • Claude Code or another supported IDE

Run in your project root directory:

Terminal window
bunx bmad-method@alpha install

You’ll see the BMAD ASCII logo:

██████╗ ███╗ ███╗ █████╗ ██████╗ ™
██╔══██╗████╗ ████║██╔══██╗██╔══██╗
██████╔╝██╔████╔██║███████║██║ ██║
██╔══██╗██║╚██╔╝██║██╔══██║██║ ██║
██████╔╝██║ ╚═╝ ██║██║ ██║██████╔╝
╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═════╝
Build More, Architect Dreams v6.0.0-alpha.16

? Installation directory: /Users/vsai/WorkSpaces/vs/vs-ai-agents
? Install to this directory? Yes

Recommendation: Use your current project directory and confirm with Yes.


? Where do custom agents and workflows get stored? bmad-custom-src
? Where do custom modules get stored? bmad-custom-modules-src
OptionRecommended ValueDescription
Custom agents/workflowsbmad-custom-srcStores custom Agents and workflows
Custom modulesbmad-custom-modules-srcStores custom modules

? What is the name of your game project? vs-ai-agents
? Where should Sprint Artifacts be stored? docs/sprint-artifacts
? What is your game development experience level? Expert
? Which game development framework or engine? Unity, Unreal Engine, Godot, Custom / Other
OptionPossible ValuesDescription
Project nameCustomYour game project name
Sprint Artifacts directorydocs/sprint-artifactsStores stories, epics, temp context, etc.
Experience levelBeginner / Intermediate / ExpertAffects how Agents explain concepts
Game engineUnity / Unreal / Godot / CustomYour game development framework

? What is the title of your project? vs-ai-agents
? What is your technical experience level? Expert - Deep technical knowledge
? Where should Sprint Artifacts be stored? docs/sprint-artifacts
? Enable Test Architect Playwright MCP capabilities? Yes
? Are you using playwright-utils in your project? Yes
OptionRecommendedDescription
Project titleYour project nameUsed for Agent context
Technical experienceChoose as appropriateOnly affects explanation style, NOT document content
Playwright MCPYesEnables Test Architect automation capabilities
playwright-utilsAs neededAdvanced features from @seontechnologies/playwright-utils

Note: Technical experience level only affects how Agents communicate with you. Documents always remain concise for LLM efficiency.


This is one of the most important choices during installation:

? Where would you like to install Codex CLI prompts?
> Project-specific - Recommended for real work (requires CODEX_HOME=<project-dir>/.codex)
Global - Simple for single project (~/.codex/prompts)

Strongly Recommended: Choose Project-specific

MethodProsCons
Project-specificProject isolation, version controllable, team sharingRequires environment variable setup
GlobalSimple configurationOnly serves single project, references fixed .bmad path

After choosing Project-specific, add to your ~/.bashrc or ~/.zshrc:

Terminal window
alias codex='CODEX_HOME="$PWD/.codex" codex'

Then run:

Terminal window
source ~/.bashrc # or source ~/.zshrc

This alias makes Codex CLI automatically use the .codex config in your current working directory.


During installation, you’ll see module installation progress:

✔ Core installed
✔ Dependencies resolved
✔ Module installed: bmb # BMad Optimized Builder
✔ Module installed: bmgd # BMad Game Development
✔ Module installed: bmm # BMad Method
✔ Module installed: cis # Creative Innovation Suite
✔ Module configurations generated
✔ Manifests generated: 61 workflows, 21 agents, 5 tasks, 1 tools, 88 files
✔ Configured 18 IDEs
ModuleFull NamePurpose
bmbBMad Optimized BuilderAgent and workflow builder
bmgdBMad Game DevelopmentGame development-specific Agents
bmmBMad MethodCore agile methodology
cisCreative Innovation SuiteCreative and innovation tools
Compiled agents:
- bmad-master, bmad-builder
- game-architect, game-designer, game-dev, game-scrum-master
- analyst, architect, dev, pm, sm
- quick-flow-solo-dev, tea, tech-writer, ux-designer
- brainstorming-coach, creative-problem-solver
- design-thinking-coach, innovation-strategist
- presentation-master, storyteller

6 | AgentVibes TTS Configuration (Optional)

Section titled “6 | AgentVibes TTS Configuration (Optional)”

After installation, you’ll be prompted to configure AgentVibes voice synthesis:

🎙️ AgentVibes TTS Setup
AgentVibes provides voice synthesis for BMAD agents with:
• ElevenLabs AI (150+ premium voices)
• Piper TTS (50+ free voices)

If you choose to install, it automatically configures:

  • 34 slash commands
  • TTS scripts
  • 16 background music tracks
  • Personality templates
Terminal window
# Launch Claude Code with MCP
claude --mcp-config .mcp.json
# AgentVibes commands
/agent-vibes:list # View all available voices
/agent-vibes:switch <name> # Switch voice
/agent-vibes:personality <style> # Set personality style

your-project/
├── .bmad/
│ ├── _cfg/ # Configuration files
│ ├── bmb/ # Builder module
│ ├── bmgd/ # Game development module
│ ├── bmm/ # Method core module
│ ├── cis/ # Creative innovation module
│ ├── core/ # Core Agents
│ └── docs/ # Documentation
├── .claude/ # Claude Code config
├── .codex/ # Codex CLI config (project-level)
├── bmad-custom-src/ # Custom Agents
├── bmad-custom-modules-src/ # Custom modules
└── docs/
└── sprint-artifacts/ # Sprint artifacts

After installation, verify with:

Terminal window
claude --mcp-config .mcp.json

Then try:

/bmad-bmm-agents-pm # Activate PM Agent
Terminal window
ls .bmad/core/agents/
ls .bmad/bmm/agents/

Terminal window
bunx bmad-method@alpha install --update

Q: How do I use BMAD in multiple projects?

Section titled “Q: How do I use BMAD in multiple projects?”

Run the installation command in each project. Project-level configurations don’t interfere with each other.

Ensure you’ve configured the CODEX_HOME environment variable and are running codex from within your project directory.


ConfigurationRecommended Choice
Installation locationProject directory (not Home)
Codex installationProject-specific
Technical levelChoose as appropriate, doesn’t affect document quality
Playwright MCPEnable (for automated testing)
AgentVibesInstall as needed

BMAD’s project-level installation allows you to:

  • Use different configurations across projects
  • Version control your AI Agent configurations
  • Share consistent development environments with team members

Start using BMAD and let AI Agents become your agile development partners!


Claude Chrome Extension: Bringing the Power of Claude Code to Everyday Tasks

Claude Chrome Extension: The “ChatGPT Moment” for Claude Code has arrived.

When Claude Code steps out of the dialog box and into your Chrome browser.


Introduction: Anthropic’s “ChatGPT Moment”

Section titled “Introduction: Anthropic’s “ChatGPT Moment””

Remember the shock when ChatGPT was first released? In that moment, AI moved from the lab into millions of homes.

Now, Anthropic is creating its own “ChatGPT moment”—not through a chat box, but via the Claude Chrome Extension, turning AI into a true “digital employee” within your browser.

The Claude Chrome Extension brings the powerful capabilities of Claude Code to ordinary users—you don’t need to know how to code or understand APIs. Just tell Claude what you want to do in your browser, and it will do it for you.

This is more than just a browser plugin; it’s a significant step toward integrating AI into daily workflows.


With the Claude Chrome Extension, you can direct Claude to perform tasks directly in your browser.

The extension enables Claude to:

  • Navigate Webpages: Automatically open and browse any website.
  • Click Buttons: Simulate user actions and execute clicks.
  • Fill Forms: Automatically populate various forms and input fields.
  • Execute Background Tasks: You can continue with other work while Claude works in the background.
  • Schedule Workflows: Set up daily or weekly automated tasks.

1. Seamless Collaboration with Claude Code

Section titled “1. Seamless Collaboration with Claude Code”

Developers can connect Chrome directly within Claude Code to:

  • Test and iterate on code in-browser.
  • Automate front-end testing processes.
  • Achieve a perfect blend of development and debugging.

The Claude Chrome Extension can operate the applications you use every day:

  • Google Drive file organization.
  • Calendar management and meeting preparation.
  • CRM system data entry.
  • Email cleanup and categorization.

Once the Claude Chrome Extension starts a workflow, you can move on to other things:

  • Claude will quietly complete tasks in the background.
  • It doesn’t require your active attention.
  • Results are automatically synchronized.

Set up periodic tasks without manual triggers:

  • Daily data report generation.
  • Weekly progress updates.
  • Regular data synchronization and backups.

ScenarioWhat the Claude Chrome Extension Can Do
Analyze Dashboard DataNavigate to analytics platforms, extract metrics, and report.
Organize Google DriveScan files, create folder structures, and auto-archive.
Calendar PrepRead schedules, extract context from emails, and flag prep.
Cross-site ComparisonRead multiple product pages and generate comparison tables.
CRM Call LogsMatch participants and contacts to generate activity logs.
Clean Promotional EmailsScan inboxes, identify marketing/newsletters, and bulk process.

Anthropic vs OpenAI: A Shifting Competitive Landscape

Section titled “Anthropic vs OpenAI: A Shifting Competitive Landscape”

The release of the Claude Chrome Extension is a strategic move for Anthropic. Let’s look at the latest market data:

MetricAnthropicOpenAI
2024 Revenue$1 Billion$3.7 Billion
2025 Forecast$7 Billion+$12.7 Billion
Growth Rate8000% (21 months)243%
MetricClaudeChatGPT
Monthly Active Users18.9 Million800 Million Weekly
Enterprise Customer Share70-80%-

The gap is closing rapidly:

  • At the start of 2024, OpenAI was 15 times the size of Anthropic.
  • By the end of 2024, this gap narrowed to 5 times.
  • Anthropic’s ARR has reached 40% of OpenAI’s.

The enterprise market is Anthropic’s stronghold:

  • Claude’s consumer user base is only 5% of ChatGPT’s.
  • Yet, with an ARR reaching 40%, it’s clear that enterprise customers are contributing significantly.
  • Enterprise clients represent more stable revenue and higher average transaction values.

ChatGPT’s success lay in making AI conversations accessible to everyone. The Claude Chrome Extension does the same, but in a different direction:

  1. From Conversation to Action: While ChatGPT taught people to talk to AI, Claude allows AI to actually do things for you.
  2. From Developers to Everyday Users: The power of Claude Code is now available to everyone.
  3. From Standalone Tools to Global Assistants: It’s no longer just a web app, but an integrated part of the entire browsing experience.

This is precisely the breakthrough Anthropic needs—using a differentiated product experience to carve out a new track in a market dominated by ChatGPT.


  1. Visit the Chrome Web Store to install the extension.

  1. Click the extension icon and select “Open Claude” to begin.
  2. Start with simple tasks and gradually explore more complex workflows.

Can also be used in conjunction with Claude Code or Claude Desktop.

While the Claude Chrome Extension is powerful, please keep in mind:

  • Start by using it on trusted websites.
  • Exercise extra caution with sensitive operations involving finances or passwords.
  • If you notice any unusual behavior, pause the extension and provide feedback immediately.

The Claude Chrome Extension represents a new direction in AI development:

  • Beyond Chat: True task execution.
  • Beyond Developer Tools: Accessible to everyone.
  • Beyond Feature Bloat: A revolution in workflow.

For Anthropic, this could be the key step in shifting the market landscape. While ChatGPT remains far ahead in user numbers, Anthropic is catching up in a different way—deeper enterprise integration and closer alignment with actual work.

In the second half of the AI competition, it’s no longer just about whose dialogue is smarter, but who can actually help users get things done.


Claude Code + MCP: Auto-Publish Articles to WeChat Official Account in Minutes

Claude Code MCP WeChat Automation

What if you could go from a simple idea to a fully researched, professionally written article published to your WeChat Official Account - all in minutes, without leaving your terminal?

This isn’t science fiction. With Claude Code and the wenyan-mcp (Model Context Protocol) server, you can create an end-to-end content automation pipeline that:

  • Researches topics using web search
  • Generates high-quality bilingual articles
  • Automatically publishes to your WeChat draft box
  • Applies beautiful formatting themes

Let me show you exactly how to set this up.


Before we begin, make sure you have:

  1. Claude Code installed (v2.0+ recommended)
  2. Docker running on your machine
  3. WeChat Official Account with API credentials (AppID and AppSecret)

If you haven’t installed Claude Code yet:

Terminal window
# Using npm
npm install -g @anthropic-ai/claude-code
# Or using Homebrew (macOS)
brew install claude-code

Verify installation:

Terminal window
claude --version
# Claude Code v2.0.74

The magic happens through MCP (Model Context Protocol) - a standard that allows Claude to interact with external tools and services.

Add this configuration to your Claude Code MCP settings (~/.claude/settings.json or project-level .claude/settings.local.json):

{
"mcpServers": {
"wenyan-mcp": {
"name": "公众号助手",
"command": "docker",
"args": [
"run",
"--rm",
"-i",
"-v",
"/path/to/your/images:/mnt/host-downloads",
"-e",
"WECHAT_APP_ID=your_wechat_app_id",
"-e",
"WECHAT_APP_SECRET=your_wechat_app_secret",
"-e",
"HOST_IMAGE_PATH=/path/to/your/images",
"caol64/wenyan-mcp"
]
}
}
}

Configuration Notes:

ParameterDescription
WECHAT_APP_IDYour WeChat Official Account AppID
WECHAT_APP_SECRETYour WeChat Official Account AppSecret
HOST_IMAGE_PATHLocal path for image storage (used for cover images)
-v mountMaps your local image directory to the container

Tip: Get your AppID and AppSecret from the WeChat Official Account Admin Platform.


The key to this workflow is defining your task in an issue file. This tells Claude exactly what you want to accomplish.

Create a file like engineering/00-issues/my-article-task.md:

---
slug: engineering/00-issues/my-article-task
---
# Issue: Write a blog about [Your Topic]
## Description
Key points to cover:
- Point 1
- Point 2
- Point 3
## Requirements
- Languages: Chinese Simplified, English
- Use `wenyan-mcp` to publish (Chinese Simplified)
- Research latest trends and data

Now comes the exciting part. Start Claude Code and reference your issue:

Terminal window
claude

Then in the Claude Code prompt:

Execute @engineering/00-issues/my-article-task.md

Starting Claude Code


Claude searches the web for relevant, up-to-date information:

Web Search

Claude fetches and analyzes multiple sources to create comprehensive content:

Browsing Articles

Claude generates the article and publishes directly to your WeChat draft box:

Task Completed

Open your WeChat Official Account admin panel - your article is waiting in the draft box:

WeChat Draft Box

Article Preview


The wenyan-mcp server supports multiple beautiful themes for your articles:

ThemeStyle
defaultClean, minimal
orangeheartWarm orange accents
rainbowColorful headings
lapisProfessional blue
piePlayful design
maizeGolden highlights
purpleElegant purple
phycatTech-focused

Specify your preferred theme when publishing:

Use the orangeheart theme when publishing to WeChat

┌─────────────────────────────────────────────────────────────┐
│ YOUR WORKFLOW │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. Define Issue 📝 Create task in .md file │
│ ↓ │
│ 2. Start Claude Code 💻 Execute the issue │
│ ↓ │
│ 3. Auto Research 🔍 Web search & analysis │
│ ↓ │
│ 4. Generate Content ✍️ Bilingual articles │
│ ↓ │
│ 5. Publish to WeChat 📱 Direct to draft box │
│ │
└─────────────────────────────────────────────────────────────┘

Specify languages in your issue file:

Languages: Chinese Simplified, English

Claude will generate both versions automatically.

Reference local images in your issue:

## Screenshots
![Step 1](path/to/screenshot1.png)

Specify where you want your blog files saved:

Output to: src/content/docs/blog/my-topic/

Articles go to your draft box first - you always have a chance to review and edit before final publication to subscribers.


IssueSolution
Docker connection failedEnsure Docker Desktop is running
WeChat API errorVerify AppID/AppSecret are correct
Images not uploadingCheck HOST_IMAGE_PATH is correctly mapped
MCP server not foundRun claude mcp list to verify configuration

This workflow transforms content creation from a tedious multi-step process into a streamlined, automated pipeline. With Claude Code + wenyan-mcp, you can:

  • Save hours on research and writing
  • Maintain consistency across bilingual content
  • Publish directly without copy-paste gymnastics
  • Focus on ideas rather than execution

The future of content creation is here - and it lives in your terminal.


Daily Journal - 2025-12-17 Accenture and Anthropic partnership

Accenture and Anthropic launch multi-year partnership to move enterprises from AI pilots to production

Section titled “Accenture and Anthropic launch multi-year partnership to move enterprises from AI pilots to production”
  • [[Forward Deployed Engineer]] / [[Reinvention Deployed Engineer]]

    • Approximately 30,000 Accenture professionals that will be trained on Claude, including forward deployed engineers (also known as “reinvention deployed engineers” at Accenture) who help embed Claude within client environments to scale enterprise AI adoption. This will comprise one of the largest ecosystems of Claude practitioners in the world. These teams combine Accenture’s AI, industry, and function expertise—along with deep partnerships with leading cloud providers—with Anthropic’s Claude models and Claude Code, plus its proven playbooks for regulated industries.
  • [[Methodology]]

    • quantify real productivity gains and ROI
    • workflow redesign for AI-first development teams
    • change management and training that keeps pace as AI evolves
  • [[Customization]]

    • Anthropic and Accenture will also co-invest in a Claude Center of Excellence inside Accenture, creating a dedicated environment for the joint design of new AI offerings tailored to specific enterprise needs, industry requirements, and regulatory contexts.

Source: Accenture and Anthropic launch multi-year partnership to move enterprises from AI pilots to production

Anthropic Legal Turned Contract Review Drudgery Into a Workflow Art With Claude


Yesterday Anthropic published a new article explaining how their legal team uses Claude / Claude Code to compress work that used to take days into a few hours—while keeping humans in the loop the whole time.

Section titled “1. Even at a top AI company, legal is still squeezed by grunt work”

Anthropic product counsel Mark described his earlier routine:

  • Replying to compliance documents and customer questionnaires
  • Editing terms of service and privacy policies
  • Reviewing blogs, emails, and marketing assets for the marketing team
  • Redlining contracts and comparing versions line by line
  • Writing a stack of privacy impact assessments (PIA)

These tasks share a few traits:

Repetitive, similar formats, high cost for mistakes, and extremely brain-draining.

He even said many things get pushed to the end of the day because they take so much time yet barely use “the best part of his brain.”

Sound familiar? If you have ever touched legal, compliance, risk, operations, or customer support, you have felt the same pain.

The Anthropic legal team did something very engineer-like:

They held a meeting and wrote on a whiteboard— “What drains the most energy? What repeats the most? What tasks do not deserve this much of our time?”

Once they had answers, they did not rush to “what AI can do.” They focused on a single question:

Which tasks do we never want to do by hand again?


Section titled “2. How to break down legal workflows: 4 real scenarios”

Over a few months, Anthropic’s legal team turned their pain points into repeatable workflows.

1) Self-serve marketing review: AI is the first gate

Section titled “1) Self-serve marketing review: AI is the first gate”

You have surely seen the previous flow:

On the night before launch, marketing would dump landing pages, push copy, and posters on legal: “Please review today; we go live tomorrow.”

Legal had to open the docs -> read end to end -> leave a pile of comments -> go back and forth for multiple rounds. It often dragged on for days.

Anthropic’s rebuild is simple but ruthless:

They built a Self-Review Tool in Slack:

  • Marketing pastes the copy into it

  • Claude calls a dedicated legal Skill file

    • It contains: past review comments, common risk points, and the team’s judgment criteria
  • Claude automatically flags:

    • Exaggerated claims?
    • Is there a source for the data?
    • Any violation of portrait rights or reputation?
    • Any implication of promises that should not be made?
  • Assigns a risk level to each issue: Low / Medium / High

  • Also provides a suggested revision

Only after passing this gate will a ticket be created and enter the legal queue.

StartupHub reported that with this flow, reviews that took days now compress to a few hours, and Slack can auto-generate a summary to help legal see the risk points clearly.

The essence:

Let AI handle the “intake form” and “basic checkup.” The true diagnosis still belongs to the doctor.


2) Side gig / external activity approval: AI asks for details first

Section titled “2) Side gig / external activity approval: AI asks for details first”

Many companies have similar processes:

If an employee wants to moonlight as an adviser, pursue a side business, or serve on a nonprofit board, they must go through “external business activity approval.”

Previously, legal would ask one-on-one about background, conflicts of interest, time commitments, and non-compete risks—going back and forth endlessly.

Here is how Anthropic runs it now:

  • The employee fills out a structured form
  • Claude reads the form
  • If information is missing, it will automatically ask follow-up questions
  • Based on company rules, it provides a recommended decision + risk explanation
  • It then enters the legal queue for an attorney to confirm approval or rejection

Lawyers now mainly focus on two buckets:

  • True edge cases
  • Higher-risk borderline situations

They separated “90% standard flow + 10% extreme judgment.”


3) Privacy impact assessments (PIA): teach AI to write the template

Section titled “3) Privacy impact assessments (PIA): teach AI to write the template”

For privacy projects, every new feature needs a fresh PIA.

The pain:

  • Templates look similar, but you still have to rewrite them each time
  • It must fit the specific scenario without missing required sections

Anthropic’s approach has two steps:

  1. Use MCP (Model Context Protocol) to connect Claude to a Google Drive folder

    • Inside are all historical PIA documents
  2. Equip Claude with a “PIA writing Skill” that spells out:

    • Document structure
    • What to focus on in each section
    • Privacy points the company cares about most

An attorney just says:

“Using the previous cases, draft a PIA for this new feature.”

Claude will:

  • First learn the style of past PIAs
  • Then draft in the same format
  • Transfer historical focus points into the new scenario

The work shifts from “write from scratch” to “edit an 80-point draft.”


Section titled “4) Legal built a “Morse code lamp,” but the point is that the barrier dropped to human language”

There is a fun detail:

Mark used Claude Code to build a “legal desk lamp” that blinks Morse code to send and receive messages—purely a personal hobby project.

But the story highlights something important:

Even a lawyer who cannot code can, by “speaking human language” to AI, build a complete mini app.

For companies, this means:

  • Legal, compliance, and operations—the people who do not code—can build workflows themselves
  • No need to first line up engineering resources or launch a big project
  • As long as they explain the rules clearly, AI can help turn them into tools

It fundamentally changes the belief that “only engineers can build tools.”


Section titled “3. The building blocks under this legal workflow”

Anthropic’s legal system rests on three building blocks:

1) Swap “what tech can do” for “what I refuse to do”

Section titled “1) Swap “what tech can do” for “what I refuse to do””

Mark’s advice is blunt:

Do not start with “what AI can do.” Start with “what work do we most want to escape.”

They followed that approach on a whiteboard:

  • Which documents are repetitive
  • What judgment calls we make every day
  • Which flows can be fully standardized

After confirming, they checked:

  • Can AI do the first pass
  • Reserve human time for disputes, exceptions, and strategic judgment

2) Skills: package team experience into callable assets

Section titled “2) Skills: package team experience into callable assets”

The official blog defines Skills as a document with instructions, scripts, and references that let Claude act like an expert for a task.

For legal, Skills do two things:

  • Keep rules consistent

    • Marketing review Skill: bakes in historical review comments
    • Different domains get different Skills: employment, commercial, privacy, corporate governance…
  • Keep the voice consistent

    • Mark had Claude read 10 of his memos
    • He taught it his structure and tone
    • When Claude drafts memos later, it can “write in his style”

Think of a Skill as:

A senior lawyer’s “plug-in memory card.”

Plug it in when needed; pull it out when you do not.


Section titled “3) MCP: turn scattered info into a “legal knowledge web””

Another key block is MCP (Model Context Protocol).

Anthropic’s legal team connected Claude to:

  • Google Drive: historical contracts, PIAs, templates, policies
  • JIRA: requests and tickets
  • Slack: conversation records
  • Calendar: key meetings and approval checkpoints

This yields two effects:

  • AI stops “hallucinating” because it can check your own materials
  • Each workflow gets just enough context

You can think of it simply:

MCP = connect AI to your “company intranet.”

Skills = teach it “how to use those materials to get work done.”


4. The single most important rule: humans must not be absent

Section titled “4. The single most important rule: humans must not be absent”

Both Anthropic’s blog and the StartupHub article keep repeating: “Legal must stay human-in-the-loop.”

In practice:

  • AI handles:

    • First-pass review and issue spotting
    • Initial risk grading
    • Drafting suggested edits and documents
  • Attorneys handle:

    • Fact-checking and citations
    • Deciding “can the company accept this risk”
    • Final external sign-off

Anthropic is explicit:

AI hallucinates; that is a fact.

So the design is: AI as accelerator, humans as brakes and steering.

For anyone rolling out AI in a company, keep this in mind:

You are not replacing legal with AI. You are using AI so legal stops being a “format fixer and typo hunter.”


After discussing Anthropic, let’s talk about borrowing the idea. Whether you use Claude, ChatGPT, DeepSeek, or your own model, you can follow the same playbook.

Here is how to start:

Section titled “1) List your team’s “legal hell list””

Pick a day and gather legal, compliance, marketing, and product:

  • Write down the tasks you never want to do for the hundredth time
  • Prioritize by “repeatability x risk control”
  • Pick one or two that are ready to pilot now

Typical candidates:

  • First-pass marketing review
  • Standard clause comparison in contracts
  • Data protection and privacy templates
  • Standard questionnaires and compliance Q&A

2) Start with “human + AI dual-layer flow,” then talk automation

Section titled “2) Start with “human + AI dual-layer flow,” then talk automation”

Jumping straight to “end-to-end auto-approval” often dies on risk and trust.

A steadier way:

  • Let AI handle “internal pre-review + draft assistance”

  • Keep the real decision flow unchanged

  • Use one to two months to check:

    • Does it make obvious mistakes?
    • Is speed truly better?
    • Does the team find it more usable?

Once it passes, consider upgrading to:

  • Self-serve tools
  • Workflows wired into internal systems
  • Added templates, Skills, and team norms

3) Feed AI your “rules” and “style” over time

Section titled “3) Feed AI your “rules” and “style” over time”

Follow Anthropic’s two-step method:

  • Rules

    • Compile a “company legal review checklist”
    • For example: banned words, mandatory disclaimers, data points that must be verified
    • Turn it into a long-lived “AI prompt doc” or Skill
  • Style

    • Give AI a few contract reviews or memos your team likes
    • Have it summarize: common structure, phrasing habits, tone preferences
    • Require all future drafts to “follow this style”

Gradually, you will have:

An AI teammate that works the way you do.


Is the automation worth it? Anthropic’s “How Anthropic teams use Claude Code” notes that many teams measure efficiency this way, and legal shows especially clear returns.

You can quantify quickly:

  • Average review time per marketing asset
  • Cycle time from “sent to legal” to “legal response” for each contract
  • Hours per week each attorney spends on repetitive documents

Do a before-and-after, and it becomes easy to justify more resources.


In one line, Anthropic Legal’s practice is:

Use AI as a rules-aware junior assistant to free senior lawyers from grunt work so they can do real judgment.

For anyone who understands the business and a bit of AI, this is a huge opportunity:

  • You can be the person who packages team knowledge into Skills
  • You can build the first “AI + legal workflow”
  • You can turn AI from a “chat toy” into true “process infrastructure”

I am curious:

In your team, what could be handed to AI to handle the groundwork if you follow Anthropic’s approach?

Give Claude Long-Term Memory: Hands-on Guide to claude-mem

claude-mem actually lets Claude genuinely “remember you”


Do you ever feel like this:

Every time you open Claude / ChatGPT to write code, you have to re-explain the project from scratch:

“I’m building an admin console, the stack is…” “Last time we stopped at user login; this time we need to add…”

Halfway through explaining, you’re already annoyed.

The model isn’t dumb; it just has no memory.

Today, let’s look at a fun little GitHub project: claude-mem—a “long-term memory” add-on for Claude Code.


In one sentence:

It automatically records what you do in Claude Code, summarizes and compresses it, and the next time you open the same project, Claude will “actively recall” past context.

More specifically, it is:

  • A Claude Code plugin
  • Automatically captures: your prompts, tool calls, file reads/writes, etc.
  • Uses Claude’s Agent SDK in the background to summarize and extract key points
  • Stores them in a local database and vector store; supports full-text + semantic search
  • When you reopen Claude Code, it injects the most relevant history back into the new conversation automatically

So the experience is:

You keep coding, and Claude becomes the partner who remembers the project background even better than you do.


2. How does it give Claude “memory buffs”?

Section titled “2. How does it give Claude “memory buffs”?”

The official README has a clear flowchart; here’s the plain-language version:

1) Session start: feed it “recent events”

Section titled “1) Session start: feed it “recent events””

Each time you start a new session in Claude Code, claude-mem digs out “recent key info” from the database, organizes it into a concise context block, and injects it automatically at the top of the conversation.

It’s like running through, in your head, before meeting a friend:

“Last time we talked about login and signup—what pitfalls did we hit?“

Throughout the development session, it keeps recording:

  • Important prompts you send to Claude
  • The “observations” from Claude’s tool calls (which files were read, what was written)
  • Some critical intermediate steps

These raw snippets are not replayed wholesale as context. Instead, they’re sent to the Worker Service, which uses Claude’s Agent SDK to summarize:

“What are the takeaways worth remembering from this session?”

For example:

  • We decided to drop a certain third-party library
  • Refactored the interface design of a module
  • Fixed a nasty bug and summarized its root cause

3) Session end: generate a “study note”

Section titled “3) Session end: generate a “study note””

When the session ends, it does one more thing:

Condenses the entire session into a “project changelog + decision digest.”

That gets stored in local SQLite (for full-text search) while also being written to a vector database like Chroma for semantic search.

Next time Claude looks up history, it won’t rummage through everything. It uses smart search + progressive disclosure to inject a small but crucial slice of context back into the chat.


1) Long-running projects: no more endless recaps

Section titled “1) Long-running projects: no more endless recaps”

Picture a real scenario.

You’re building a SaaS admin console over 3 months, constantly interrupted by meetings and changing requirements.

Without claude-mem, every return to the project looks like this:

  • Skim Git logs and docs first
  • Paste a long prompt to explain the background to Claude
  • Only then does Claude get into the groove

With claude-mem installed:

  • As soon as a new session opens, Claude already knows:

    • What the project is about
    • Which modules changed recently
    • Which pitfalls you’ve hit so you don’t repeat them

You only need to say:

“Pick up where we left off on permissions and finish the export feature.”

Claude can “follow the thread” instead of looking lost.

2) mem-search: a “project time machine”

Section titled “2) mem-search: a “project time machine””

claude-mem also ships a neat skill: mem-search.

You can ask it in natural language:

  • “Find how we designed the login API before.”
  • “That file upload bug—how did we fix it back then?”

Unlike a basic code keyword search, mem-search looks through conversations + tool calls + summarized knowledge, and lets you control how much context to inject via progressive disclosure, saving tokens.

Simply put:

It turns “I vaguely remember we discussed this” into “I can surface it on demand.”

3) Web UI: see what Claude is “thinking” in real time

Section titled “3) Web UI: see what Claude is “thinking” in real time”

The project provides a Web Viewer at http://localhost:37777 by default:

  • Watch the current session’s “memory stream” in real time

  • Search history

  • Check exactly what got recorded and what will be injected

For privacy-conscious teams, this matters a lot. You can visually confirm whether anything sensitive was stored.

If you have sensitive content (internal systems, secrets, user data), wrap it in <private> and claude-mem will exclude it from persistence.

The model can still use that info within the current session, but it won’t be written into long-term memory, reducing leakage risk.

That’s a nice plus for compliance-focused orgs.


The author made installation match Claude Code habits closely.

In Claude Code’s terminal, open a new session and run two lines:

/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

Restart Claude Code and it starts working automatically.

More advanced (optional) moves:

  • Run the local worker service and Web UI
  • Tune configs (what to record, token strategy, etc.)
  • Customize settings or integrate with more complex environments

For most developers, the default setup is already great. Once you’re hooked, explore docs on “Context Engineering” and “Progressive Disclosure” later.


These groups will feel the biggest gains:

  • Lead developers on long projects If you spend a year on one big project, you’ll love it.

  • People who rely on Claude Code as their primary IDE helper Daily AI pair programming makes memory benefits obvious.

  • Side project / open-source enthusiasts If you pause for a week or two, you can still “resume seamlessly.”

  • Just occasionally asking Claude to write a small script
  • One-off experiments or single-file utilities

At that intensity, claude-mem’s long-term memory edge is minor—install it if you feel like it.

  • Requires running a local daemon and database
  • Team use needs data storage and access policies
  • It’s a community project; you need to watch upgrades and compatibility

That said, judging by stars and activity, the community is healthy. If you hit issues, open an Issue and discuss.


From a time/money perspective, claude-mem pays off mainly by:

  • Saving time No more repeating project context or digging through old chats.

  • Reducing mistakes Avoid re-hitting old pitfalls; remember prior decisions.

  • Stabler collaboration When projects pause or team members change, history is easier to restore.

If you’re already paying for Claude / GPT, every “re-explaining the project” burns tokens. claude-mem essentially helps you:

Turn “explaining repeatedly” into “explain once, reuse many times.”


Summary: make AI the “teammate with great memory”

Section titled “Summary: make AI the “teammate with great memory””

For many people, AI is now essential to daily development. But an AI without memory is more like a short-term intern:

  • Capable in the moment
  • Limited long-term project value

A “memory add-on” like claude-mem upgrades it into a long-term teammate who truly understands the project context.

If you’re already coding with Claude Code, set aside an hour on the weekend to install it and try:

You might suddenly realize— the real ceiling of LLMs isn’t “how much code they write,” but “how much of the journey they can remember.”


How are you making AI “remember projects” today?

  • Handwritten docs?
  • Copy-pasting giant prompts each time?
  • Or simply giving up and letting it remember whatever it can?

Share your approach in the comments, or how you’d use claude-mem for your projects.

Anthropic Internal AI Development Survey: Frontend Shines, Architecture Is Hardest to Hand Off to AI

Introduction: Is AI Really Making Engineers More Productive?

Section titled “Introduction: Is AI Really Making Engineers More Productive?”

This year, every developer friend around me keeps asking the same question:

“I use Claude/Copilot every day, but is it really worth it? Are the vendors overselling me?”

Coincidentally, Anthropic turned the real usage data of 132 internal engineers and researchers into a detailed survey and interviews, plus several charts.

It is like an AI vendor giving itself a physical exam. Who is delighted, who is stumbling—everything is written in the numbers.

Let’s look at the report from a working engineer’s perspective and talk about: In software engineering, which tasks have the highest ROI with AI, and which ones should you not rush to offload to a model?


Anthropic asked 132 engineers and researchers a series of very concrete questions:

  • How much of your daily work do you do with Claude?
  • What do you mainly use it for? Debugging, new features, refactoring, tests, documentation, or design and planning?
  • For each task type, does working with Claude make you spend more or less time?
  • Does the volume of output (code, docs, deliverables) go up or down?

They also compared changes over time:

  • A year ago, employees estimated that about 28% of their work used Claude, self-reporting a +20% productivity lift.
  • Now that number has risen to 59% of work done with Claude, with an average self-reported productivity +50%; around 14% of “power users” believe they improved by over 100%.

Another independent study is also striking: using 100,000 real conversations, Anthropic estimated that the median task completion time dropped by roughly 80%.

It sounds dramatic, but engineers know self-reported productivity needs a haircut. The more useful takeaway is: by task type, where are the real gains and where is the fluff?


II. Overall Pattern: Time Saved Is Small, Output Gain Is Big

Section titled “II. Overall Pattern: Time Saved Is Small, Output Gain Is Big”

That figure you saw is one of the core findings:

  • Left: after using Claude, for a given task, time spent goes down, stays the same, or goes up.
  • Right: in the same amount of time, the amount of output goes up by how much.

Looking across all tasks, two patterns stand out:

  1. For most tasks, time is only slightly lower

    • Many points sit around “-1” (a light decrease).
    • It means people are saving a little, not cutting the time in half.
  2. But the output increase is more obvious

    • In the right plot, most points are in the “+1 to +2” range.
    • So even when time only drops a bit, the amount produced jumps a lot.

A hidden detail: In the raw data, a small group actually spends more time on some tasks.

Their interview explanations feel very real:

  • Cleaning up after Claude—fixing the mess it made, redoing debugging and cleanup.
  • Spending time to understand code they did not write themselves.
  • Or because Claude exists, they simply work more thoroughly: more tests, more exploration.

In short:

Time does not vanish; it gets “reinvested” into more work.


III. ROI by Task Type: Frontend Wins, Design and Infra Lose

Section titled “III. ROI by Task Type: Frontend Wins, Design and Infra Lose”

Looking at the distribution and my own experience, the ROI ranking is clear.

1) ROI Ceiling: Frontend, New Features, Debugging, Testing, Documentation

Section titled “1) ROI Ceiling: Frontend, New Features, Debugging, Testing, Documentation”

These tasks share traits:

  • Outcomes are easy to verify

    • Frontend: run it and you immediately see if the UI is right.
    • Debugging: reproduce the bug, run tests—pass or fail.
    • Tests and docs: format and coverage are obvious at a glance.
  • Task boundaries are clear

    • “Make this component responsive.”
    • “Add a set of unit tests for this code.”
    • “Write a README for new teammates.”

In these jobs, the most annoying part for humans is: mechanical, repetitive, boring to write, yet quality is visible instantly.

This matches a keyword Anthropic staff highlighted:

“I’m more willing to hand Claude tasks that are easy to verify.”

The report also notes that engineers increasingly use Claude for frontend visualization, implementing UI, and building small tools, even encouraging backend engineers to write frontend and become “quasi full stack.”

From an ROI lens, these tasks are short, fast projects:

  • Model does the work
  • Human reviews
  • If it breaks, roll back and redo
  • Beginners can supervise

Frontend is a clear beneficiary—screens, interactions, styles iterate quickly. You focus on user experience itself instead of wrestling with CSS details.

2) Lower ROI: Design and Planning, Infrastructure/DevOps

Section titled “2) Lower ROI: Design and Planning, Infrastructure/DevOps”

On the other end: high-level design, system planning, Infra/DevOps.

Anthropic’s report shows two things:

  • Employees explicitly said:

    • “I usually keep high-level thinking and design to myself and hand implementation/debugging tasks to Claude.”
    • Design and planning tasks show the smallest productivity lift.
  • Infra and DevOps tasks are used less often; time and output gains are limited.

This aligns with software-engineering common sense:

The more a task depends on experience, context, taste, and organizational strategy, the harder it is to fully hand it to AI.

Designing a new system architecture requires considering:

  • What the business looks like in five years
  • The team’s current stack
  • Who maintains it and who is on-call
  • Cost budget, compliance, and security

Claude can:

  • Generate versions of architecture diagrams
  • List risks and trade-offs
  • Draft design docs

But the person who approves is still you. Here AI is a smart adviser, not the decision-making CTO.

Infra/DevOps is similar:

  • The hard part is

    • Knowing the company’s complex network topology
    • Dealing with legacy scripts and configs
    • Knowing who owns the pager when things break
  • AI can write scripts, explain logs, draft runbooks.

  • But it is hard to run a command to production without looking.

From an ROI angle:

Frontend, new features, debugging, testing, documentation -> low investment, fast return

Design, planning, Infra -> high value, but AI rarely “saves you a ton of time” directly


IV. Verifiability: The “Watershed” That Decides AI Effectiveness

Section titled “IV. Verifiability: The “Watershed” That Decides AI Effectiveness”

In interviews, Anthropic summarized a pragmatic delegation rule: engineers are more willing to hand Claude tasks that are:

  • Easy to verify
  • Low complexity or clearly bounded
  • Not under extreme quality bars (e.g., one-off debug scripts)
  • Repetitive, dull, but cannot be skipped

This can be abstracted into one word: verifiability.

Think of it this way:

  1. Tasks with tests or demos are great for AI to charge ahead

    • Frontend pages, backend endpoints, data-processing scripts
    • Run them and see whether the result is in the expected range
  2. Tasks relying on “taste” and “judgment” need human oversight

    • System design, UX design, security strategy
    • Often no standard answers, only trade-offs
  3. Local problems vs. global problems

    • Changing one component or writing a doc is a local problem.
    • Planning a cross-team technical roadmap is a global problem.

Claude delivers huge ROI on local, verifiable tasks. On global, fuzzy tasks, it is better for brainstorming, lists, and comparisons, not for directly giving the final plan.


V. Practical Tips for Typical Teams: Don’t Rush to Make AI the Architect

Section titled “V. Practical Tips for Typical Teams: Don’t Rush to Make AI the Architect”

If you lead an engineering team or build solo, you can draw a clear “sphere of influence” for AI, following Anthropic’s approach.

1) Start by Treating AI as “Manual Labor + Recorder”

Section titled “1) Start by Treating AI as “Manual Labor + Recorder””

Let Claude handle:

  • Debugging

    • Help locate stack traces, explain errors, reproduce bugs
    • Write temporary scripts for validation
  • Tests, documentation, and comments

    • Auto-complete unit tests, generate mocks
    • Summarize PR changes, generate README and API docs
  • Frontend and visualization

    • Produce page scaffolds and style options
    • Build internal tools, dashboards, data visualizations
  • Small refactors and “paper cuts”

    • Break a blob of code into functions
    • Rename variables, extract shared logic

For these, just write clearer acceptance criteria. Results will beat asking it to “think up an architecture from scratch.”

2) Design and Planning: Use AI as a Brainstorming Partner

Section titled “2) Design and Planning: Use AI as a Brainstorming Partner”

For high-level design, Claude works best when you:

  • Ask for multiple architecture options with pros/cons
  • Let it draft RFC/technical design first versions
  • Simulate reviews from different personas (e.g., “what would security ask?”)

Decision-making, trade-offs, and final sign-off stay with you.

3) Infra/DevOps: Scripts and Docs Can Be Delegated, Production Commands Are Yours

Section titled “3) Infra/DevOps: Scripts and Docs Can Be Delegated, Production Commands Are Yours”

In Infra scenarios, it is safe to give AI:

  • Explanations of complex Kubernetes YAML or Terraform configs
  • CI/CD pipeline templates
  • Log reading and first-pass root-cause analysis

For commands or change plans that hit production, require:

  • A human to review again
  • A teammate’s review
  • A dry run in staging when needed

Set a simple team rule:

“Any command that directly affects production must be edited and executed by a human.”

Following Anthropic, you can draw a table for the team:

  • Rows: Debug / Frontend / New features / Tests / Docs / Refactoring / Design / Infra …

  • Columns:

    • Does AI draft it?
    • Is AI allowed to finish it alone?
    • Who reviews the final output?

This becomes your “AI usage policy.” Update it quarterly; when models upgrade, move more tasks into the AI column.


VI. The Future Engineer: More Full Stack, With Stronger Judgment

Section titled “VI. The Future Engineer: More Full Stack, With Stronger Judgment”

One survey insight resonated with me:

  • Employees estimated that 27% of Claude-assisted work would not exist without AI—extra refactors, dashboards, internal tools.

So Claude is not just speeding up existing work; it makes you do valuable things you “never had time for.”

At the same time, many worry:

  • With less time writing code, will my hands get rusty?
  • Supervising AI needs experience, yet experience is being eaten by AI.

This is the “oversight paradox”:

Using AI well requires strong judgment, and judgment itself needs hands-on practice.

A healthier approach might be:

  • Use AI boldly for high-ROI tasks.
  • Keep a portion of “handwritten training” for yourself.
  • Treat AI as an accelerator for your skill growth, not a substitute.

In the long run, what will engineers look like?

  • More like a mix of product + architecture + project manager + AI wrangler.
  • Focus more on “what to build” and “why,” rather than “exactly how this line of code looks.”

Conclusion: Use AI in the Right Places and Become the Team’s “Productivity Arbitrageur”

Section titled “Conclusion: Use AI in the Right Places and Become the Team’s “Productivity Arbitrageur””

Anthropic’s internal survey points to a clear mindset:

  • Do not expect AI to 10x every task.
  • The real gap is whether you dare and know how to give it the right tasks.

If you are an engineer or tech lead, take a moment now to list your work:

  • Which tasks are easy to verify, repetitive and dull, and can be handed to Claude today?
  • Which tasks involve high-level design and team strategy—let it act as “think tank,” not “ghostwriter”?

Draw that “AI task map,” and your productivity in the team is already a big step ahead.

From Exploration to Fix: How Claude Code Thinks and Reasons Through a SQLAlchemy Transaction Rollback Issue

This technical blog is distilled from a real production incident investigation. It focuses on how Claude Code “explores → thinks → reasons” to quickly pinpoint the root cause, ship the smallest viable fix, and propose follow‑up structural improvements.

The problem occurred in the mailflow service in production. The core error was:

This Session's transaction has been rolled back due to a previous exception during flush.
To begin a new transaction with this Session, first issue Session.rollback().
Original exception was: (sqlalchemy.exc.InvalidRequestError) Can't reconnect until invalid transaction is rolled back

From the surrounding logs, the failure happened when executing an INSERT into the emails table. Subsequent database operations then entered a “cascade failure” state.

  • Context: While handling inbound emails (parsing, creating records, forwarding, moving IMAP folders), mailflow occasionally fails the entire processing chain.
  • Goals:
    • Identify the primary trigger of the transaction failure;
    • Explain why all subsequent DB operations report the same error;
    • Restore processing with the smallest, lowest‑risk change;
    • Provide structural improvement suggestions to increase robustness.

2. Exploration Path: From Symptoms to Evidence

Section titled “2. Exploration Path: From Symptoms to Evidence”

Leveraging Claude Code’s code search and cross‑context capabilities, we proceeded “from symptoms to root cause” in order:

  • Locking onto logs and trigger point

    • The logs show the exception stems from the SQLAlchemy Session state: after a prior transaction failure, rollback() was not performed, leaving the current Session invalid.
  • Locating key code paths

    • mailflow/app/db.py: connection and session factory definitions.
    • mailflow/app/mail.py: main business flow, record creation, and commit points.
    • mailflow/app/utils.py: logging and WeCom notification entry notify_and_log.
  • Evidence 1: Module‑level global Session

    • At the top of mail.py there is:
      session = session_factory() # module‑level global Session
    • Once any flush/commit fails, this global Session becomes invalid, and all subsequent DB operations that rely on it will fail until an explicit session.rollback() is issued.
  • Evidence 2: Missing exception handling and rollback

    • Multiple session.commit() calls lack try/except/rollback protection:
      • Creating the mail record (create_mail)
      • Relating attachments to mail (_relation_attachment_and_mail)
      • Updating status when dealing with request results (deal_requests_result)
      • Large sections of the main flow in process_mail

Conclusion: The first failed DB operation puts the global Session into an invalid state. Because rollback() is missing, all later commits and even queries on that path fail with the same error, forming a “cascade failure”.

3. Reasoning Chain: From Hypothesis to Verification

Section titled “3. Reasoning Chain: From Hypothesis to Verification”
  1. Hypothesis: An INSERT/UPDATE exception (possibly from data constraints, transient network issues, or the pool) invalidates the global Session; without rollback(), subsequent steps (status updates, attachment relations, mail moves) all fail.

  2. Code verification:

    • Found the global session = session_factory();
    • Searched for session.commit() call sites — most lack except: session.rollback();
    • This matches the error semantics exactly.
  3. Strategy: Move fast with minimal change to restore stability first, then evaluate structural refactoring.

We prioritized the fix in three levels (P0 → P2):

  • P0 (immediate, smallest change): add session.rollback() in exception handlers so the Session can self‑recover.
  • P1 (comprehensive guard): wrap every commit() with try/except/rollback to avoid any single failure taking down the rest of the flow.
  • P2 (structural): replace the module‑level global Session with scoped_session to isolate session state across processing flows (recommended, not mandatory for the hotfix).
  • Add rollback in the main flow (mailflow/app/mail.py)
try:
# Parse, determine mail_type, build attachment parser, etc.
...
except Exception as err:
session.rollback() # Key: restore session state
notify_and_log(...)
process_status = False
  • Guard status updates when handling request results (wrap both success and failure branches)
try:
mail.move_to = 'Done'
mail.status = '20000'
session.commit()
except Exception as err:
session.rollback()
notify_and_log(...)
raise
  • Guard establishing mail–attachment relations
try:
for item in a_list:
attach = Attachment(...)
session.add(attach)
session.commit()
except Exception as err:
session.rollback()
notify_and_log(...)
raise
  • Add protection for creating the mail record create_mail
try:
mail = Email(...)
session.add(mail)
session.commit()
return mail
except Exception as err:
session.rollback()
notify_and_log(...)
raise

Eliminate the risk where a “global Session drags down all flows” by using scoped_session:

from sqlalchemy.orm import sessionmaker, scoped_session
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory) # thread/coroutine‑local isolation
# Acquire/release at business entrypoints:
session = Session()
try:
...
finally:
Session.remove() # recycle the local session

Note: scoped_session provides better isolation in concurrent/multithreaded environments and reduces cross‑request contamination. The production hotfix first ensures rollback semantics are correct and complete; then evaluate the migration cost/benefit.

Suggested validation steps:

  • Single reproducible mail replay: replay a previously failing mail and observe whether the chain recovers;
  • Observe logs: the message “Can’t reconnect until invalid transaction is rolled back” should no longer appear;
  • Manual spot‑check: verify IMAP folder moves, forwarding, and database state;
  • Controlled load: increase the number of sample mails to ensure multiple commit points correctly roll back and continue.
  • Anti‑pattern: a module‑level global Session, once invalid, causes chain‑wide cascade failures.
  • Principle: every commit() should be wrapped by try/except + rollback; also rollback() in the top‑level exception handler of the main flow.
  • Design: adopt a failure‑resilient session model (scoped_session or acquire/release per processing unit).
  • Operations: log and alert immediately (this project uses WeCom via notify_and_log), and include key identifiers (uid, subject, time, to_list) in the message.

This “explore → reason → fix” path generalizes to most code‑level issues:

  1. Quickly bound the problem: start from the error semantics and match the most likely layer (transaction/session management).
  2. Evidence‑driven search: find the relevant files, variables, and functions (session_factory, commit() call sites).
  3. Hypothesize → falsify/corroborate: propose “global Session + no rollback → cascade failure”, then find direct evidence in code.
  4. Smallest change first: add rollback() so the Session can recover and stop the bleeding.
  5. Structural improvement: propose scoped_session as the follow‑up path, balancing benefit and migration cost.

Let Claude Skills Be Your Power‑Up: 3‑Step Quickstart, Highlights, and 8 Real‑World Scenarios

Have you had this moment? You grind on reports like brick‑laying or pull all‑nighters on slides, but a teammate seems to have a cheat code—one prompt and they ship a brand‑compliant pack. The newly released Claude Skills is how to install that “cheat” into Claude. It wraps repetitive work into modules that auto‑match and auto‑run—like “expertise packs” on demand.


One folder = one skill. Inside are instructions (SKILL.md), scripts, and resources. Claude auto‑loads and uses the skill for fitting tasks. You don’t need to code to turn your work patterns into reusable skills.

Quick highlights – Auto trigger: semantic matching to the right skill – Composable: multiple skills can collaborate – Code execution: run scripts when needed, stable and reproducible – Works everywhere: Claude.ai, Claude Code, and API – Enterprise‑ready: brand rules, compliance checks, spreadsheet automation


How it “automates”: 5 moments from discovery to collaboration

Section titled “How it “automates”: 5 moments from discovery to collaboration”
  1. Scan & discover: on start, Claude scans available skills and reads short summaries (minimal context budget).
  2. Match: when you ask, Claude checks whether a skill fits.
  3. Activate: if matched, it loads the skill’s instructions/resources/scripts.
  4. Execute: follows instructions and runs code tools when needed.
  5. Collaborate: skills can run in parallel or in sequence.

Three steps to install & use (2‑minute lift‑off)

Section titled “Three steps to install & use (2‑minute lift‑off)”

A. Install Claude Code (optional but recommended)

Terminal window
npm install -g @anthropic-ai/claude-code

B. Enable Skills in Claude / Claude Code Turn on Code execution / File creation in settings, then enable Skills or upload a ZIP (for custom skills).

C. Create a custom skill (minimal structure)

  • Create folder my-skill/
  • Write SKILL.md: YAML header with name and description; body with steps and constraints; add resources/ or scripts if needed.
  • Place it in your user or project area (e.g., .claude/skills or project/claude/skills) so Claude can discover it.

Want to start fast? Grab official/community examples and tweak.


SKILL.md snippet (example):

---
name: Branded PPT Maker
description: Convert an outline to a PPT with our brand fonts, colors, and slide layout rules.
allowed-tools:
- python:read-only
- bash:read-only
---
# Instructions
- Read /resources/brand-guidelines.pdf
- Use title/body styles from page 5
- Build slide outline from user's bullets
- Export as .pptx

Key idea: write human‑readable triggers, boundaries, inputs/outputs. Throw brand guides, templates, and examples into resources/. Add scripts for stable steps.


Work scenarios: 4 “this saves absurd time” uses

Section titled “Work scenarios: 4 “this saves absurd time” uses”

Feed templates + rules. Auto formulas, pivot tables, and chart palettes. Weekly reviews in 10 minutes.

Give brand guides and master slides. The skill applies layout, character counts, and alignment—and can output a presenter script.

Put cases and selectors in resources; scripts click/assert and the skill returns a screenshot report.

Load policies and banned‑term lists; the skill flags risky sentences and suggests rewrites.


Life scenarios: 4 “you’ll keep using it” ideas

Section titled “Life scenarios: 4 “you’ll keep using it” ideas”

Provide city, days, and preferences. The skill builds itinerary, routes, and budget—and exports an Excel breakdown.

Encode goals and allergens in SKILL.md. The skill returns a weekly meal plan and shopping list.

Import utility CSVs. The skill categorizes, fixes errors, visualizes, and outputs who pays what.

Bundle a template + checklists. The skill generates the group announcement, sign‑in sheet, and supplies list.


  • Security? Only enable trusted skills; code‑executing skills run sandboxed with permissions.
  • Who gets it? Pro, Max, Team, Enterprise—available on Claude.ai, Claude Code, and API.
  • Where to find examples? Start with official/community repos—adapt a close match.

In short, Claude Skills productize your workflow. Package experience, rules, and templates into triggerable, reusable, and composable skills. Install a “report skill” today, add a “brand skill” tomorrow—and your AI really will learn your way of working.

Which task would you skill‑ify first? Share in the comments.

Build an Efficient, Lightweight, and Controlled Spec‑Driven Workflow with OpenSpec + Claude Code

When teams start collaborating with AI coding assistants, clearly answering “what to build, how to build it, and how we know it’s done” becomes crucial. This guide walks you through a practical, reviewable, and traceable development workflow using OpenSpec (documentation‑driven development) together with Claude Code (an intelligent coding assistant).

Who this is for:

  • Teams that want specs before changes in multi‑person collaboration
  • People/teams that want AI assistants embedded into a standard workflow
  • Projects that require approval, archiving, or compliance control
  • Specs are truth: openspec/specs represents the currently delivered source of truth.
  • Propose before changes: any change impacting behavior/architecture/security/performance starts in changes/[id].
  • Three‑phase loop: Create change → Implement tasks → Archive and codify.
  • AI works to specs: Claude Code always uses OpenSpec as the authoritative context.

Install OpenSpec (global):

Terminal window
npm install -g @fission-ai/openspec@latest
openspec --version

Initialize at the project root:

Terminal window
openspec init

Initialization will:

  • Write a cross‑assistant AGENTS guide at the repo root
  • Generate the openspec/ directory structure
  • Establish unified collaboration instructions for Claude Code / Cursor / Codex, etc.
  • Later you can run openspec update to refresh the guidelines

Recommended directory structure (auto‑generated):

openspec/
├── project.md # Project conventions, background, stack
├── specs/ # Delivered capabilities (source of truth)
│ └── [capability]/
│ ├── spec.md # Requirements + scenarios (canonical format)
│ └── design.md # Technical approach (optional)
├── changes/ # Proposals (pending changes)
│ ├── [change-id]/
│ │ ├── proposal.md # Why / What / Impact
│ │ ├── tasks.md # Implementation checklist
│ │ ├── design.md # For large changes
│ │ └── specs/ # Delta for affected capabilities
│ │ └── [capability]/spec.md
│ └── archive/ # Archived changes

OpenSpec provides project context and process standards; Claude Code executes the Read → Generate → Implement → Verify cycle. After initialization, start your Claude Code session with prompts like these:

  • Fill in project context:

Please read openspec/project.md. Based on the repo’s current state, help me fully document project goals, tech stack, conventions, external dependencies, constraints, and naming standards.

  • Create the first change proposal:

I want to add “[your feature]”. Please create an OpenSpec change proposal (changes/[id]/) including proposal.md, tasks.md, and the relevant specs delta under changes/[id]/specs/.

  • Explain/enforce the workflow:

Using openspec/AGENTS.md, explain the three‑phase workflow and strictly follow it in subsequent steps: propose and validate first, implement after approval, archive when complete.

Tip: After installation, Codex/Windsurf/Cursor, etc. will also pick up the same guidelines so multiple assistants collaborate consistently.

Three‑Phase Workflow (from openspec/AGENTS.md)

Section titled “Three‑Phase Workflow (from openspec/AGENTS.md)”
  1. Create Change
  • When: new capability, breaking change, architecture/security/performance strategy changes
  • Steps:
    • Pick a unique change-id (kebab‑case, verb‑prefixed: add-, update-, remove-, refactor-)
    • Generate proposal.md, tasks.md, and design.md if needed
    • Write specs delta using operation headers: ## ADDED|MODIFIED|REMOVED|RENAMED Requirements
    • Validate: openspec validate <id> --strict
    • Only implement after approval
  1. Implement Change
  • Steps:
    • Read in order: proposal.mddesign.md (optional) → tasks.md
    • Implement strictly in tasks.md order; check off each item when complete
    • Update overall task status only when all are completed
  1. Archive Change
  • After deployment:
    • Move changes/[id] to changes/archive/YYYY-MM-DD-[id]/
    • If capability behavior changed, update openspec/specs/
    • Run strict validation: openspec validate --strict
    • Optional: openspec archive [change] [--yes|-y] to auto‑archive (tooling changes may use --skip-specs)
  • Each requirement uses ### Requirement: ...
  • Each requirement must have at least one scenario using a level‑4 heading:
#### Scenario: Returns success
- **WHEN** input is valid
- **THEN** return 200 with data

Do not use bullets or bold text instead of a scenario heading (the parser will fail).

  • Three types of delta changes:
    • ## ADDED Requirements for new capabilities
    • ## MODIFIED Requirements for behavior changes (paste the full updated requirement block, not a diff)
    • ## REMOVED Requirements for removals (include rationale and migration)
    • ## RENAMED Requirements for renames only
  1. Explore current state
Terminal window
openspec spec list --long
openspec list
# Full‑text search via ripgrep is also recommended:
rg -n "Requirement:|Scenario:" openspec/specs
  1. Choose a change ID and scaffold
# Example: add-direct-youtube-subtitle-download
# You can also ask Claude Code to create the directory and file skeletons for you
  1. Write the delta (example)
## ADDED Requirements
### Requirement: Direct subtitle download
The system SHALL request subtitle files directly from YouTube without relying on M3U8.
#### Scenario: Download succeeds
- **WHEN** a valid video and subtitle language are provided
- **THEN** download the corresponding subtitles and save to the target directory
  1. Strict validation
Terminal window
openspec validate add-direct-youtube-subtitle-download --strict
  1. Approval → Implementation
Terminal window
openspec apply add-direct-youtube-subtitle-download
  • After approval, have Claude Code implement items in tasks.md step by step
  • Check off one item when it’s done; proceed until all are - [x]
  1. Archive and codify
Terminal window
openspec archive add-direct-youtube-subtitle-download --yes
openspec validate --strict
  • Always let Claude Code “read” first: openspec/project.md, relevant specs/[capability]/spec.md, and changes/[id]/proposal.md|tasks.md
  • Execute strictly against tasks.md as the single source of truth; check off as you go
  • Prioritize edits directly related to the proposed change; avoid unrelated refactors
  • When ambiguous, ask 1–2 clarifying questions before scaffolding
  • When referencing code locations, use src/module.ts:42 single‑line pointers
  • Built‑in validation: openspec validate [change] --strict; if issues occur, use --json to diagnose
Terminal window
openspec list
openspec list --specs
openspec show [item] # change or spec
openspec diff [change]
openspec validate [item] --strict
# Init / update
openspec init [path]
openspec update [path]
# Archive (post‑deploy)
openspec archive [change] [--yes|-y]

Common flags:

  • --json machine‑readable output
  • --type change|spec to specify the object type
  • --strict strict validation
  • --skip-specs archive only (skip specs update)
  • --yes|-y skip confirmation (good for CI)

Proposal vs. Direct Fix — When to Use Which?

Section titled “Proposal vs. Direct Fix — When to Use Which?”

Propose (recommended) when:

  • New features/capabilities
  • Breaking changes (API/Schema)
  • Architecture/pattern shifts
  • Performance/security strategy changes that affect behavior

Direct edits are fine when:

  • Bug fixes (restoring intended behavior)
  • Copy/format/comments
  • Non‑breaking dependency upgrades
  • Minor configuration tweaks
  • Tests that cover existing behavior
  • “Change must have at least one delta”
    • Check that changes/[id]/specs/ contains .md files
    • Ensure files include ## ADDED|MODIFIED|REMOVED operation headers
  • “Requirement must have at least one scenario”
    • Scenario headings must be #### Scenario: ... (level‑4 heading)
    • Do not use bullets or bold text
  • Delta parsing failures
    • Use openspec show [change] --json --deltas-only to debug
    • Compare with originals under openspec/specs/ and ensure MODIFIED is a full replacement block

Use OpenSpec to make Requirements → Design → Tasks → Changes explicit from day one and treat them as the project’s source of truth. Then leverage Claude Code for efficient execution and collaboration so AI delivers within clear boundaries. The benefits:

  • Specs first to reduce rework; approvals up front to lower risk
  • Task closure with traceable outputs; archivable changes for reusable knowledge

Claude Code 2.0.17 Update: Haiku 4.5 Takes Execution, Plan with Sonnet — Faster and Cheaper

Today’s update is very kind to developers who code with Claude Code.

Claude Haiku 4.5 launches — cheaper and faster; Plan mode defaults to Sonnet for planning and switches to Haiku for execution. In practice, projects run smoother and your wallet hurts less. Official pricing/positioning and how this release hooks into Claude Code both support that conclusion.

Haiku 4.5: $1 / $5 (input/output per million tokens) — aimed at real‑time, low‑latency work, with optimizations for coding, sub‑agent collaboration, and computer‑use scenarios. Compared with Sonnet 4 from May, it’s well over 2× faster at about one‑third the cost, while delivering “near‑frontier” performance on many coding tasks.

Why “more economical”? Compare peers on pricing:

  • Sonnet 4.5: $3 / $15 (input/output).
  • Opus 4.1: $15 / $75 (input/output).

This means you can hand off execution steps that don’t need the “strongest brainpower” to Haiku 4.5. Bills slim down immediately and responses feel snappier. If you run many agents, hit backend services, or trigger calls frequently from your IDE, the value is obvious.

Summary: Haiku 4.5 = coding ability close to Sonnet 4 + faster speed + one‑third the price. It’s not a “make‑do small model”, it’s a “deployment‑grade workhorse”.

Highlight 2: Plan with Sonnet, execute with Haiku (the 2.0.17 default pairing)

Section titled “Highlight 2: Plan with Sonnet, execute with Haiku (the 2.0.17 default pairing)”

In Claude Code 2.0.17, a crucial detail: Plan mode uses Sonnet by default for planning, then automatically switches to Haiku for execution. That mirrors real workflows in the terminal/VS Code: deep reasoning with Sonnet, batch implementation with Haiku.

  • Version signal: the VS Code extension is now 2.0.17, released with the October update.
  • Official framing: Sonnet 4.5 remains the primary engine behind Claude Code, handling long tasks and complex planning; Haiku 4.5 fills the execution seat with more speed and lower cost.

This plan/execute layering follows the familiar pattern of “frontline model for Plan, next‑tier model for implementation” — except now Haiku 4.5 takes the more capable spot on the execution side.

Real‑world take: Opus is phenomenal (and pricey); Sonnet is steady; Haiku now carries

Section titled “Real‑world take: Opus is phenomenal (and pricey); Sonnet is steady; Haiku now carries”

After several large runs, here’s the blunt take:

  • Opus: expansive ideation, cross‑stack architecture, deep retrieval — rock‑solid. But the bill is hard to stomach. If you also hand it execution, you get great results and a racing heartbeat.
  • Sonnet 4.5: currently the most usable “coding brain” in the Claude family. In Plan mode it thinks clearly: strategy, steps, and risk flags are all there.
  • Haiku 4.5: the MVP for execution. Running agent subtasks, fanning out in parallel, scaffolding, moving files, getting tests green — it’s fast and frugal. For front‑end scaffolds, mass renames, fixture generation, it barely “breaks a sweat”.

In short: Use Sonnet for expensive “thinking”; give Haiku the bulk “hands‑on”. Your speed goes up, costs come down, and stability is easier to control.

Getting started (for busy engineering teams)

Section titled “Getting started (for busy engineering teams)”
  • Keep the Plan→Exec split: clarify the hard parts, then dispatch subtasks in parallel; let Haiku 4.5 handle execution.
  • Lean on parallelism and sub‑agents: spin up multiple Haiku 4.5 workers; coordinate with a Sonnet 4.5 orchestrator.
  • Make costs visible: track API usage, measure call shares across Haiku/Sonnet/Opus, and review a sprint‑length invoice.
  • Match model to scenario: real‑time assistants, support tickets, low‑latency orchestration → favor Haiku 4.5; complex refactors and multi‑repo surgery → Plan with Sonnet 4.5.

No flashy tricks here — this update makes “useful + economical” a daily development default. Plan with Sonnet, execute with Haiku. Code moves fast and spending is transparent.

What’s your take? Which tasks see immediate gains with Haiku 4.5? Share real‑world results in the comments.

Break the “etc.”: Clarity for Claude Code

One‑line takeaway: AI coding speed can’t fix fuzzy specs. To make Claude Code truly low‑friction, break every “etc.” into a checklist, turn acceptance into an executable script, and let automation run the tests.


Have you ever written a requirement like: “Show key device info on the home page (power, volume, etc.).”

Then at QA time, the AI only implements the first three. The “etc.” simply disappears. It’s not that the AI isn’t smart; the signal you gave wasn’t precise. Claude Code “does less” when your instructions are vague—it will reasonably but incompletely narrow the scope. That’s not a bug; it’s a boundary reminder for human‑AI collaboration.

By the way, Anthropic just bumped Haiku to 4.5: cheaper, faster, and coding performance close to Sonnet (now available in Copilot too). It’s faster, yes—but it still won’t auto‑complete your “etc.”


What you see: the less you write before “=”, the less you get after it

Section titled “What you see: the less you write before “=”, the less you get after it”
  • You wrote “power, volume, brightness, etc.”
  • Claude Code reads this as three explicit items + one implicit “etc.”
  • Result: code, automated tests, and docs all cover only the first three

It’s not AI “cutting corners.” It’s AI prioritizing what’s verifiable. Explicit items can produce code and tests; ambiguous ones get skipped. This shows up repeatedly in research and industry reports—with incomplete or vague specs, AI helpers are more likely to miss features, even when they produce code faster.


A copy‑and‑use solution: don’t let “etc.” ship to production

Section titled “A copy‑and‑use solution: don’t let “etc.” ship to production”

This workflow works for any app, admin, or web project. Steal it.

1) Turn every “etc.” into a data‑driven checklist

Section titled “1) Turn every “etc.” into a data‑driven checklist”

Write the nouns as a table and add “status, source, display rules, empty‑state policy, error policy” for each item. Example fields:

  • Name: Power / Volume / Brightness …
  • Domain: On/Off; 0–100 …
  • Source: local cache / backend API / Bluetooth …
  • Display: icon, label, unit
  • Empty: show “—” or greyed out
  • Error: timeout, disconnect, permission‑denied placeholders

The payoff: AI can generate complete UI + validation + empty states + error handling, not just “three components that look right.”

Tip: Use Gherkin/BDD for acceptance, and write behavior as a Given‑When‑Then script. Human‑readable, machine‑testable.


2) Upgrade acceptance from “verbal agreement” to “executable”

Section titled “2) Upgrade acceptance from “verbal agreement” to “executable””

Convert the checklist into Gherkin scenarios, then have AI generate the automation (e.g., Cypress/Playwright):

Feature: Device key info panel
Scenario Outline: Render each key info item
Given the device exposes "<name>" with value "<value>"
When I open the home page
Then I should see "<label>" and formatted "<value>"
Examples:
| name | value | label |
| Power | On | Power |
| Volume | 70 | Volume |
| Brightness | 40 | Brightness |
| … | … | … |

Research shows: generating Gherkin from user stories first, then turning it into executable tests (Cypress, etc.) significantly improves coverage and control.


3) Put reuse in the data layer to avoid re‑implementing the same thing

Section titled “3) Put reuse in the data layer to avoid re‑implementing the same thing”

Don’t write multiple near‑duplicate infos() scattered across modules. Extract a reusable data mapping and renderer: one schema, consumed everywhere.

  • keyInfo.schema.ts: fields, domain, formatters, empty‑state policy
  • keyInfo.adapter.ts: unify sources (API, Bluetooth, cache)
  • KeyInfoPanel.tsx: pure presentation, no business logic
  • keyInfo.spec.ts: table‑driven tests; add one schema item = get more tests for free

Result: when you later add “battery temperature,” you just update the schema and everything else follows. That’s engineering the “etc.”


  • On PRs, automatically run: type checks, static rules, unit + acceptance tests.
  • Gate: if checklist count ≠ test‑covered count, reject the merge.
  • Add security and compliance scans to prevent AI‑introduced latent risks.

Unit tests tell you “what broke.” Acceptance tests tell you “is it actually complete.” You need both.


5) Use Claude Code’s latest features—just don’t expect mind‑reading

Section titled “5) Use Claude Code’s latest features—just don’t expect mind‑reading”
  • Claude Code Plugins: bundle “checklist generation → Gherkin → test coverage checks” into an installable workflow your team can share.
  • Haiku 4.5: cheap and fast, perfect for mass‑producing the “checklist → scenarios → tests” grunt work. Rolling out in Copilot too.
  • Remember: faster ≠ understands you better. Clarity is the true force multiplier.

Quick checklist (paste into your team wiki)

Section titled “Quick checklist (paste into your team wiki)”

Shared definitions

  • Break every “etc.” into a tabular checklist with domain, source, display, empty, and error policies.
  • Write one Gherkin scenario per item.

Automation

  • Use Claude to generate Cypress/Playwright scripts.
  • CI rule: checklist count = passed scenario count.

Engineering reuse

  • schema + adapter + pure UI component.
  • New item = update schema; tests and UI follow automatically.

Security & quality

  • Static analysis + dependency/secret checks.
  • No merge if gates fail.

Claude Code isn’t slacking. It follows the boundaries you set. When you turn ambiguity into structure and acceptance into execution, AI becomes a reliable teammate.

Where does your team most often write “etc.”? How are you addressing it? Share in the comments.

Ship a Rails feature in minutes with Claude Code: Document‑Driven dev + RSpec BDD


Ever felt this pain? A device reports multiple states within a minute and your database turns into a wall of “noise”.

Here’s a general, reusable practice: in Rails, merge repeated reports that arrive within a short, configurable time window into a single “golden record”.

I’ll use Claude Code with a document‑driven approach: start from a single page of specs → generate BDD scenarios → validate with RSpec → minimal implementation → write findings back to the doc. The loop is fast, stable, and traceable. If you’re new to Claude Code, the official docs outline a clear playbook and best practices.


Our “public version” requirement (desensitized)

Section titled “Our “public version” requirement (desensitized)”

Business context (generic)

An “intelligent fitness band” may report multiple heart‑rate/status events within one minute. To avoid redundancy, we want to:

  • Within a configurable time window (default 1 minute), grouped by device and type, merge multiple events into one;
  • Keep the latest record within the window (i.e., the last one wins);
  • Write to a unified work record table, ensure idempotency, and keep merge provenance for audit and traceability.

Document‑Driven

Put the above into a single “feature spec” document. That document doubles as the product contract and acceptance criteria. From it, we derive BDD scenarios and tests. This follows the same spirit as “Specification by Example/ATDD/BDD”: examples are the single source of truth.


Claude Code + BDD: from doc to executable acceptance

Section titled “Claude Code + BDD: from doc to executable acceptance”

Why Claude Code

It’s a terminal‑native coding copilot that actively pulls context. It connects code, docs, dependencies, and scaffolding, turning ideas into runnable structure quickly. The docs include hands‑on tips such as how to organize repositories so the agent “understands” your intent.

Prompt template (paste into Claude Code)

Role: Senior Rails engineer + test coach Goal: Implement “device report merge” as a reusable capability Deliverables:

  1. Based on the spec below, generate RSpec BDD scenarios and edge cases (Rails + Capybara/request/service layer);
  2. Provide a minimal implementation skeleton (service object, queries, transaction, idempotency strategy);
  3. Propose rollback and audit logging;
  4. Write all assumptions back to the doc under “Open Questions”. Attachment: the feature spec (paste the “public version” requirement above)

Why RSpec + BDD

RSpec reads like behavior. Tests are documentation. Rails’ official guide also clarifies test layers. With Capybara/request specs you can do API acceptance and system flows.


Acceptance examples (trimmed BDD thinking)

Section titled “Acceptance examples (trimmed BDD thinking)”

User story

  • As a data platform, within one minute, multiple reports of the same device and record type should be merged into one, taking the last record as the truth. This keeps queries clean and metrics correct.

Key scenarios

  • In‑window merge: t=00:10 and 00:40 → save 1 row, payload from 00:40.
  • Cross‑window no‑merge: t=00:10 and 01:15 → save 2 rows.
  • Idempotent writes: repeated requests do not produce duplicate merge results.
  • Auditable: keep source IDs and window parameters.

Tip: Put these examples in the doc/feature file so they serve both discussion and automated tests.


spec/services/record_merger_spec.rb
RSpec.describe RecordMerger do
let(:device_id) { "device-123" }
let(:window) { 1.minute }
it "merges multiple records within window, keeps the latest" do
create(:work_status, device_id:, recorded_at: Time.current - 40.seconds, payload: { hr: 85 })
create(:work_status, device_id:, recorded_at: Time.current - 10.seconds, payload: { hr: 92 })
result = described_class.call(device_id:, record_type: :work_status, window:)
expect(result.payload[:hr]).to eq(92)
expect(WorkStatus.where(device_id:).count).to eq(1)
end
it "does not merge across windows" do
create(:work_status, device_id:, recorded_at: Time.current - 75.seconds)
create(:work_status, device_id:, recorded_at: Time.current - 10.seconds)
described_class.call(device_id:, record_type: :work_status, window:)
expect(WorkStatus.where(device_id:).count).to eq(2)
end
end

Reference: See RSpec/Capybara conventions for feature tests and dependency constraints.


  • Entry point: service object RecordMerger.call(device_id:, record_type:, window:)
  • Query: same device + same type + recorded_at within the “natural time window”
  • Merge strategy:
    • Use the record with the max recorded_at as the base data
    • Persist the rest as the provenance set, e.g., merged_from: [ids...]
  • Idempotency & concurrency:
    • App‑level mutual exclusion by device + window (e.g., with_advisory_lock)
    • Unique index on the critical key (device + window start, or a computed idempotency key)
  • Audit:
    • Record merge_window_sec, merged_count, merged_from
    • Emit event logs for tracing and replay

For broader coverage, add request/system tests to verify API I/O. Rails’ testing guide explains test responsibilities across layers.


Make AI truly accelerate: engineering checklist

Section titled “Make AI truly accelerate: engineering checklist”
  • Keep the spec in the repo root with a consistent name so Claude Code can auto‑pull context.
  • Advance one micro‑goal at a time: get “in‑window merge” green first, then expand to idempotency and audit.
  • Write back to the doc frequently: new edge cases, pitfalls, and decisions go to “Open Questions/Decision Log”.
  • Backups and milestones: long sessions may compress context—split sessions at milestones, tag them, and keep local snapshots. AI is a power tool; you are still the craftsperson.

Industry feedback echoes this: Claude Code is rolling out across teams, long‑context models keep improving, and large‑repo analysis is getting steadier.


What the deliverables look like (team template)

Section titled “What the deliverables look like (team template)”
  1. One‑page feature spec (background, goal, scope, glossary, examples, open questions)
  2. RSpec suite (service + request/system tests, with edges and regression)
  3. Service object + indexes/locks (minimal viable)
  4. Event log + dashboards (merge hit rate, storage saved, query latency deltas)

Value is measurable: docs are the contract; tests are the acceptance; logs are the operational review.

Iteration stays smooth: adding a “2‑minute window” or “window per type” is just add examples → run tests → small tweaks.


Document‑Driven + BDD does not mean “write more docs”; it means making the doc an executable product contract. With Claude Code, you compress the chain from idea → tests → implementation → review to hours. Collaboration gets smoother, delivery more stable, and reading the code feels like reading a story.

How would you land this merge capability in your team? Any stronger idempotency key designs? Share in the comments.

One Prompt, Three Stacks: Shipping Session Auto‑Lock with Claude Code

Write an absurdly short prompt and the agent patches Web (TypeScript), App (Flutter), and API (Rails) in one go: adds the feature, wires permissions, localizes strings, and even creates migrations and runs checks. The best part: easy to write, easy to reuse.

Sounds unbelievable? Read on.


  • Claude Code has plugins: slash commands, sub‑agents, MCP servers, and lifecycle hooks bundled into installable units. Teams can turn cross‑stack edits into a standard pipeline.
  • MCP (Model Context Protocol) is like giving AI a USB‑C port: plug IDEs/agents into your repos, databases, and tools with structured read/write and execution.
  • Remote MCP is supported: connect to cloud services with auth; in enterprise multi‑repo/multi‑environment setups it’s much simpler.
  • Official best practices for agentic coding emphasize structured goals and checklist‑style requirements, making outcomes more reliable.
  • New models and ecosystem momentum help. Sonnet 4.5 is stronger for complex agents and “computer use” scenarios; paired with plugins/MCP it makes the path from prompt to patch much smoother.

A stand‑in scenario: Session Auto‑Lock Duration

Section titled “A stand‑in scenario: Session Auto‑Lock Duration”

We’re adding a new item under Security Settings: Session Auto‑Lock (Duration).

  • Two options: Standard (2 minutes) and Strict (30 seconds)
  • Only authorized users can view/modify
  • Web Admin, App Settings, and API change together
  • i18n in English and Chinese

This feature is generic enough and avoids any sensitive business logic.

A structured prompt for Claude Code (drop‑in)

Section titled “A structured prompt for Claude Code (drop‑in)”

Treat the following as a “work order”: short sentences, imperative verbs, 2–4 lines per block. Fewer back‑and‑forth questions, more results.

Task: Add "Session Auto-Lock Duration" to Security Settings across Web (TypeScript), App (Flutter), and API (Rails).
Context:
- Two options: standard=2 minutes, strict=30 seconds. Default=standard.
- Only authorized users can view/modify this setting.
Requirements:
1) Web Admin:
- Add a dropdown field under Security Settings.
- Options: Standard / Strict. Bind permission key: session_auto_lock.
- Localize: en_US, zh_CN.
2) Mobile App:
- Add the same dropdown in Security Settings screen.
- Read/write to user/device security config. Hide/disable if unauthorized.
- Localize: en_US, zh_CN.
3) API:
- DB migration: add string column "session_auto_lock_duration" with default "standard".
- Model enum: STANDARD/STRICT/ALL_OPTIONS.
- Permission registration for "session_auto_lock".
- Validation: only allow ALL_OPTIONS; return 403 if unauthorized.
4) Copy:
- en_US: "Standard: 2 minutes", "Strict: 30 seconds"
- zh_CN: "标准(2分钟)", "严格(30秒)"
5) Review checklist:
- Permission gating works in Web/App/API.
- Default renders as "standard".
- i18n strings appear correctly.
- Ship diffs per repo with tests passing.

This “clear landing points + checklisted requirements” style works best for agentic coding. Claude Code also recommends structured instructions to reduce iteration.

What changes look like across the three stacks

Section titled “What changes look like across the three stacks”
  • Add a Session Auto‑Lock dropdown under Security Settings.
  • Bind permission key session_auto_lock; hide or disable if unauthorized.
  • i18n:
    • en_US: Standard / Strict
    • zh_CN: 标准(2分钟)/ 严格(30秒)
  • Add the same dropdown on the Security page.
  • Read/write to the security configuration; disable or hide if unauthorized.
  • Copy matches Web for consistency.
  • Migration: session_auto_lock_duration, default standard.
  • Model constants: STANDARD / STRICT / ALL_OPTIONS.
  • Permission registration: session_auto_lock; whitelist validation on write; 403 if unauthorized.

These steps can be chained via plugins + MCP: the agent reads/writes across repos, generates migrations, runs tests, and opens PRs.

Preparation

  • For Web/App/API, wire up a lightweight agent or expose the sequence as a plugin command.
  • Connect local/remote MCP; bind repos and CI.

Execution

  • Trigger with the “work‑order‑style” prompt above.
  • The agent produces patches, migrations, i18n, and permission registration; then opens MR/PR.

Review

  • CI runs Lint/Tests; failures go back to the agent for fixes.
  • Humans review only key diffs and acceptance criteria.
  • Need compliance/auditing? Add operation logging and rollback scripts to the plugin.
    • Note: tooling is increasingly focused on governance and safety; agent platforms are improving policy and usage controls.

  • Don’t write scattered instructions. Short imperative sentences with concrete targets work best.
  • Hard‑code the permission keys, defaults, and whitelist options; don’t leave them to model “creativity”.
  • Provide the final copy strings up front to avoid another round trip.
  • Remote MCP is great, but enforce authentication and least privilege; separate environments and roles.
  • Save this prompt in the team’s instruction library/plugin. Next time you only swap the “feature name + enum options”.

Let standards handle the complex parts, and humans keep the simple parts. With one structured prompt + pluginized agent + MCP, you can flatten the “cross‑stack, cross‑repo, cross‑language” busywork. You focus on defining the requirement and making the final call; let the machine run the rest.

What do you think? Would this Session Auto‑Lock approach fit your project?

Triple Your HarmonyOS App Development Speed with Claude Code + Documentation-Driven Programming + BDD Business-Driven Testing

This methodology specifically addresses three major pain points: “AI can write code but doesn’t understand HarmonyOS,” “ArkTS keeps throwing errors,” and “regression testing can’t keep up.” The core principle: Drive Claude Code with documentation, and secure quality through BDD automation.


Introduction: Don’t Chat Randomly with AI – Write Good Documentation First

Section titled “Introduction: Don’t Chat Randomly with AI – Write Good Documentation First”

Many developers immediately tell AI: “Help me build a HarmonyOS app for Bluetooth scanning, connecting, and time synchronization.” The result? Claude Code produces seemingly sophisticated code that turns completely red upon compilation. Are you familiar with ArkTS? Do you understand the ArkUI lifecycle? How do you handle regression testing? All uncertain.

HarmonyOS officially provides ArkTS coding standards, ArkUI declarative development paradigms, and performance practices – these are standard components that Claude Code “crashes repeatedly if not learned properly.” ArkTS is HarmonyOS’s primary language, sharing roots with TypeScript but having its own semantics and ecosystem. Writing with old JavaScript habits makes it easy to fall into traps. The good news is: Claude Code already supports “reading repositories, editing files, writing and running tests, executing terminal commands.” As long as you provide the right context, it can consistently produce engineered results.


I. Documentation-Driven Programming: Make Claude Code Follow Your Lead

Section titled “I. Documentation-Driven Programming: Make Claude Code Follow Your Lead”

Objective: Clearly explain requirements, value, implementation, and acceptance criteria on one page; let Claude Code “build according to specifications” within the HarmonyOS context.

1) Write “One-Page” Requirements (can be directly placed in repository /docs/feature-xxx.md)

Section titled “1) Write “One-Page” Requirements (can be directly placed in repository /docs/feature-xxx.md)”
  • Functionality: Bluetooth device scanning → list display → connection → time synchronization → status reading → command sending → disconnection

  • Business Value: Store associates complete device initialization in 1 minute, reducing manual errors by 80%

  • Platform: HarmonyOS NEXT, ArkTS + ArkUI; DevEco Studio build

  • Interface/Model: Device names start with XX; display battery level after connection; “injection” command returns success flag

  • Acceptance Criteria (BDD format):

    • Given Application is on the home page
    • When Click “Start Scan”, see device starting with XX in list and click Connect
    • Then Enter connected page, see device name/battery level; clicking “Sync Time,” “Refresh Status,” “Send Injection Command” all return success

Remember to include key ArkTS/ArkUI constraints and best practices in documentation: naming, state management, performance considerations, etc. (from official style guides and state management guidelines). Provide specifications directly to Claude Code – it will follow these rules during generation.

2) Initial System Prompt for Claude Code (place in .claude/primer.md)

Section titled “2) Initial System Prompt for Claude Code (place in .claude/primer.md)”
  • Project framework (ArkUI page structure, directory conventions)
  • ArkTS code style requirements (variable/component naming, null checks, error handling)
  • Component inventory & event flow (Button → scanning → list → connection)
  • Test-first approach: Generate BDD scenarios and ArkTS test stubs first, then supplement business code
  • Failure retry: compilation error → read error → modify minimal set only

Officials and community both emphasize standards-driven coding, which significantly reduces rework and performance issues. Claude Code itself also recommends customizing context and environment (e.g., ignoring irrelevant files, providing dedicated README/CONTRIBUTING), which can significantly improve hit rates.

3) Place “Process Description + Acceptance Steps” in README

Section titled “3) Place “Process Description + Acceptance Steps” in README”

The image below shows our manual acceptance steps for this feature, used for manual verification and providing context for Claude Code:

Index/Connected Manual Acceptance Instructions

This text will be absorbed by Claude Code as “executable documentation”: it can write UI flows first, then supplement logic and tests (Claude officially claims to “write and run tests, edit files, commit code”).


II. BDD Business-Driven Testing: Transform “Documentation” into “Executable Specifications”

Section titled “II. BDD Business-Driven Testing: Transform “Documentation” into “Executable Specifications””

In one sentence: Write requirements as Gherkin scenarios, run tests on DevEco/arkXtest framework, test red → AI fix → test green again.

Feature: Scan and connect device
Scenario: Find and connect device with prefix XX
Given App on Index Page
When I tap "Start Scan"
Then I should see a device starting with "XX" in the list
When I tap "Connect" on that device
Then I should be on Connected Page with name and battery shown

The advantage of Gherkin/BDD is transforming “business language” directly into executable specifications, continuously validating whether system behavior matches documentation.

  • DevEco/arkXtest System: Provides unified framework for unit testing + UI testing + performance testing; UI test scripts execute on top of unit tests, meeting end-to-end validation needs.
  • IDE Support: DevEco Studio integrates testing framework and code test entry points, facilitating execution on real devices/simulators.

Some documentation also mentions HarmonyOS/ArkTS testing capability upgrades in the NEXT version, supporting more modern syntax and parameterization techniques, which can be adopted in your engineering templates as needed (based on official and authoritative sources).

3) Example: UI Scenario Test Framework (extracted from actual project structure)

Section titled “3) Example: UI Scenario Test Framework (extracted from actual project structure)”

ArkTS UI Scenario Test Snippet

This test does three things:

  1. If not scanned, try clicking “Start Scan,” otherwise log and skip
  2. Wait for device discovery
  3. Locate device with specified prefix and click connect, assert entry to connected page

This type of UI test case structure aligns with arkXtest’s design philosophy: drive UI operations with APIs, consolidate results uniformly in the testing framework.

4) Make “Test Red → AI Fix → Test Green Again” a Pipeline

Section titled “4) Make “Test Red → AI Fix → Test Green Again” a Pipeline”
  • Claude Code Loop: When failures occur, paste compilation/runtime logs back into conversation for minimal modification fixes (Claude’s official “environment tuning + context minimization” recommendations are crucial here).
  • IDE/CI Integration: One-click execution in DevEco Studio locally; CI integration with real devices/simulators for regression (refer to DevEco test entry points and official testing documentation).
  • Visual Acceptance: Place the manual acceptance step diagrams above in wiki, run Gherkin + UI tests for each version, ensuring “documentation is truth.”

III. Implementation Manual: 7-Step Checklist from 0 to 1

Section titled “III. Implementation Manual: 7-Step Checklist from 0 to 1”

Step 1 | Project Initialization

  • Create ArkTS project in DevEco Studio; select ArkUI declarative paradigm; confirm target API/device.
  • Recommend pulling ArkTS style guide and performance practices into repository /guides for both human and AI reference.

Step 2 | One-Page Requirements

  • Clearly write functionality, value, interfaces, states, exceptions, acceptance scenarios (Given/When/Then).
  • Place screenshot-style manual acceptance steps in README (the diagram section above).

Step 3 | Claude Code Startup

  • Use .claude/primer.md and /docs as primary context; limit it from reading irrelevant large files.
  • Have it generate test stubs & Gherkin first, then supplement business code and ArkUI pages.

Step 4 | ArkTS/ArkUI Coding

  • Follow naming, componentization, state management constraints; pay attention to performance practices and null/exception handling.

Step 5 | Test Implementation

  • Use arkXtest / DevEco testing for unit tests + UI tests; use Gherkin as top-level use case description (can call UI test APIs in step definitions).

Step 6 | Iterative Fixes

  • Feed failure logs to Claude Code for minimal fixes; loop locally/CI until all green.

Step 7 | Knowledge Base Accumulation

  • Record pitfalls & FAQ in /kb: such as BLE permissions, lifecycle, list performance.
  • Next time, only need to modify “one-page” requirements and a few step descriptions, Claude Code can reuse context to continue generation.

IV. Results: Quality, Speed, and Understanding – Triple Success

Section titled “IV. Results: Quality, Speed, and Understanding – Triple Success”
  • Speed: With the “documentation as code” approach, Claude Code is more stable on HarmonyOS projects, reducing back-and-forth guessing.
  • Quality: arkXtest + DevEco testing aligns unit tests/UI/performance, automates regression, leaving manual work for exploratory validation only.
  • Understanding: Standards and performance practices written in documentation, humans and AI follow the same rules, new team members can master ArkTS/ArkUI basics in 1 day.

V. Replicable Template (You Can Copy Directly)

Section titled “V. Replicable Template (You Can Copy Directly)”
/docs
feature-ble-connect.md # One-page requirements + acceptance
ui-flow.md # Interface flow and states
/guides
arkts-style-guide.md # Extracted + linked official standards
performance-notes.md # ArkTS performance practices
/tests
features/ble_connect.feature # Gherkin
ui/ble_connect.test.ets # UI scenario tests
.kb
ble-permissions.md
.claude/primer.md
  • Background/Value
  • Constraints (API/permissions/device prefix)
  • Acceptance Scenarios (5-7 Given/When/Then items)
  • Rollout/rollback strategy

Conclusion: Close the Loop Between “Documentation—Testing—Code”

Section titled “Conclusion: Close the Loop Between “Documentation—Testing—Code””

When you write documentation that can directly accept, Claude Code has the possibility to write correct ArkTS on the first try; When you get BDD scenarios running, each version can have one-click regression. This is how we consistently achieve “faster speed + more stable quality” in HarmonyOS projects.

What do you think this approach is still missing? Share your scenarios in the comments.

Use BMAD in Codex like Claude Code: Put a multi‑role AI squad in your repo

Install Codex and BMAD, map BMAD’s “multi‑role experts” into AGENTS.md, then in the terminal say “*agent analyst”. Codex will run a BMAD‑style agile loop from requirements to delivery.


Two pain points in projects: no one writes clear requirements, and even when they do, no one lands them properly.

BMAD turns roles like Business Analysis, Architecture, Product, Development, QA, and Scrum into version‑controlled Markdown agents. Combined with Codex’s AGENTS.md, you work as if an AI squad is embedded in your repo.

This is a practical, copy‑ready path:

  1. Install BMAD
  2. Update AGENTS.md to register BMAD roles
  3. One prompt to bring in the Analyst and start

  • Codex understands AGENTS.md: it follows your project rules to build, check, and propose changes, in both CLI and IDE.
  • BMAD provides reusable “Agent as Code”: each role is a .md with tasks, checklists, templates, and workflows.
  • Together: “project rules + multi‑role collaboration + executable checks.” It feels like a real team that never forgets the process.

Step 1: Install BMAD (3‑minute quick path)

Section titled “Step 1: Install BMAD (3‑minute quick path)”

Ensure Node.js v20+ first.

Run in your project root:

Terminal window
# Recommended one‑command install/upgrade
npx bmad-method install
# Or, if you’ve cloned before
git clone https://github.com/bmad-code-org/BMAD-METHOD
cd BMAD-METHOD
git pull
npm run install:bmad

This installs BMAD’s core structure and scripts into your project (including .bmad-core, templates, and helpers), preparing the agents for use.

Tip: If you see path errors, make sure directories include the leading dot (use .bmad-core, not bmad-core). This is a common gotcha.


AGENTS.md is a “README for agents.” It lives at the repo root, as standard Markdown. Use it to document your build/test/style/PR process and any local conventions.

Codex, Cursor, Gemini, and other agents read it; agents will follow rules you define here.

To help Codex quickly locate BMAD roles, add a small “BMAD Agents” section to AGENTS.md and list a clean mapping. Many teams prefer a YAML snippet for clarity and tooling, for example:

# BMAD Agents
agents:
- id: analyst
path: .bmad-core/agents/analyst.md
- id: architect
path: .bmad-core/agents/architect.md
- id: bmad-master
path: .bmad-core/agents/bmad-master.md
- id: bmad-orchestrator
path: .bmad-core/agents/bmad-orchestrator.md
- id: dev
path: .bmad-core/agents/dev.md
- id: pm
path: .bmad-core/agents/pm.md
- id: po
path: .bmad-core/agents/po.md
- id: qa
path: .bmad-core/agents/qa.md
- id: sm
path: .bmad-core/agents/sm.md
- id: ux-expert
path: .bmad-core/agents/ux-expert.md

Note: AGENTS.md is Markdown and doesn’t require YAML—tables or lists are fine. The key is to let agents reliably locate those role .md files.


Step 3: Start the BMAD Analyst inside Codex

Section titled “Step 3: Start the BMAD Analyst inside Codex”

Install the CLI (choose one):

Terminal window
npm i -g @openai/codex
# or
brew install codex

Then run codex in your project root and sign in with your ChatGPT account when prompted.

3.2 “One‑liner” to bring the Analyst online

Section titled “3.2 “One‑liner” to bring the Analyst online”

Once in Codex, say:

*agent analyst
Hi, I’m Mary — Business Analyst.
All commands must start with *.
1. *help — Show available commands
2. *brainstorm {topic} — Facilitate structured brainstorming
3. *create-competitor-analysis — Create competitor analysis doc
4. *create-project-brief — Create project brief
5. *doc-out — Output current document
6. *elicit — Run advanced elicitation
7. *perform-market-research — Create market research doc
8. *research-prompt {topic} — Generate deep research prompt
9. *yolo — Toggle skip confirmations
10. *exit — Exit Business Analyst persona

BMAD’s Web/IDE flows surface *help and *analyst as common entry points. Bringing the same “numbered options + task‑driven” style into Codex gives you a similar experience.

Reminder: BMAD’s Analyst/Architect/PM/Dev roles each define commands/checklists in agents/*.md. Some tasks (e.g., brainstorming) reference files in .bmad-core/tasks/*. If paths are correct, the agent can load them.


A “zero‑to‑one” cheat sheet (use as‑is)

Section titled “A “zero‑to‑one” cheat sheet (use as‑is)”

Setup

  • npx bmad-method install (or npm run install:bmad)
  • Verify .bmad-core exists and Node v20+ is installed

Configure

  • Document “how to build/test/code style/PR rules” in AGENTS.md
  • Add the “BMAD Agents” mapping so role files resolve correctly

Execute

  • Open codex and send the *agent analyst startup command
  • Produce docs/brief.md → Architect drafts architecture → Scrum Master shards into stories → Dev implements → QA validates

Make it faster: let Codex handle checks and PRs

Section titled “Make it faster: let Codex handle checks and PRs”

Codex naturally runs commands and reviews code in your repo (and can be @‑mentioned in PRs). When paired with AGENTS.md rules for tests/style/build, you get a tight loop of local validation and automated review.


  • Wrong path: missing the leading dot in .bmad-core causes load failures → standardize on dotted paths.
  • Scattered rules: put build/test/style/submit conventions in AGENTS.md so agents execute consistently.
  • Too many roles to remember: use *help in session or have the agent present numbered next steps.

BMAD turns human roles into versioned code. Codex turns execution into automatable actions. Wire them together and you get an AI team that doesn’t tire, reproduces well, and never forgets the rules.

Which project will you hand to this squad first? Share in the comments.


Which BMAD role would you customize deeply — Analyst, Architect, or QA?
Share your reason and one team rule that must always be enforced.

Rapidly Develop a HarmonyOS 6 Bluetooth Device Management App with Claude Code: Bluetooth Interaction, ArkTS Compilation Fixes, and TDD/BDD Practices

Rapidly Develop a HarmonyOS 6 Bluetooth Device Management App with Claude Code: Bluetooth Interaction, ArkTS Compilation Fixes, and TDD/BDD Practices

Section titled “Rapidly Develop a HarmonyOS 6 Bluetooth Device Management App with Claude Code: Bluetooth Interaction, ArkTS Compilation Fixes, and TDD/BDD Practices”

This article demonstrates how to quickly develop a Bluetooth device management app for Huawei’s HarmonyOS 6 using Claude Code. It covers typical features such as receiving Bluetooth advertisements, connecting to devices, setting the time, synchronizing status, performing infusions, and retrieving logs. The article also focuses on strategies for fixing ArkTS compilation errors and implementing TDD/BDD-oriented testing.

— Suitable for teams aiming to build BLE device applications through a “write, test, iterate quickly” approach.

1. Development Goals and Device Protocol Overview

Section titled “1. Development Goals and Device Protocol Overview”
  • Target Device: A Bluetooth device.
  • Typical Commands:
    • Read status, synchronize time, perform infusion, read records.

Implementation Files and Data Models:

  • entry/src/main/ets/utils/BleService.ets: An all-in-one wrapper for scanning and discovery, connection, notifications, and command sending.
  • entry/src/main/ets/utils/BleCommand.ets: Command construction (including CRC, length, and time/dose encoding).
  • entry/src/main/ets/utils/BleResponseParser.ets: Response parsing.
  • entry/src/main/ets/utils/BleAdvertisingParser.ets: Advertising data parsing (local name, UUID, manufacturer data, etc.).

2. How Claude Code Accelerates Native ArkTS Development

Section titled “2. How Claude Code Accelerates Native ArkTS Development”
  • Code Navigation and Refactoring:
    • Quickly locate BLE-related entry points, cross-references, and dependencies using commands; maintain consistency with batch renaming and interface extraction.
  • Assisted Fixing of ArkTS Compilation Warnings/Errors:
    • Automatically points out rule violations like arkts-no-spread and unknown/any, suggesting replacement code and type completion.
  • Generating Test Skeletons and Adding Assertions:
    • Quickly create and extend unit tests and UI integration tests based on Hypium.

By combining these capabilities, a high-frequency feedback loop of “modify → run tests → analyze logs → fix/refactor” can be established, significantly shortening the cycle from protocol design to an end-to-end working application.

3. Detailed Breakdown of the Bluetooth Interaction Flow

Section titled “3. Detailed Breakdown of the Bluetooth Interaction Flow”

1. Receiving Bluetooth Advertisements (Scanning and Parsing)

Section titled “1. Receiving Bluetooth Advertisements (Scanning and Parsing)”
  • Multi-path Scanning (HarmonyOS API v15+):
    • Entry Point: entry/src/main/ets/utils/BleService.ets startScan(...)
    • Event: BLEDeviceFind is continuously reported, internally using BleAdvertisingParser to parse the local name, service UUID, manufacturer data, etc.
  • Advertising Parsing: entry/src/main/ets/utils/BleAdvertisingParser.ets
    • Covers major AD types like Flags, Complete/Incomplete UUIDs, and Manufacturer Specific Data, making it easy to quickly identify the target device.

Associated Discovery Service: entry/src/main/ets/utils/BleDiscoveryService.ets encapsulates the discovery list, sorting by RSSI, automatic stopping on timeout, and a “trusted device” caching strategy. The UI side can directly subscribe to status/result callbacks.

2. Connecting to a Device and Enabling Notifications

Section titled “2. Connecting to a Device and Enabling Notifications”
  • After connecting and discovering services, you must “subscribe, then enable notifications, then read once more” before writing:
    • Enable Notifications: entry/src/main/ets/utils/BleService.ets
      • First, subscribe to the callback: gattClient.on('BLECharacteristicChange', ...)
      • Then, enable it: setCharacteristicChangeNotification(..., true)
      • Optionally, perform a readCharacteristicValue once to “warm up” the notification channel (required by some devices).
  • Notification Callback: entry/src/main/ets/utils/BleService.ets onCharacteristicChanged(...)
    • Use lowercase UUID comparison to avoid misses due to case differences.
    • Convert characteristic.characteristicValue to an ArrayBuffer before dispatching to a pending callback or a unified protocol parser.
  • Sending a Write: entry/src/main/ets/utils/BleService.ets sendCommand(...)
    • ArkTS disables object spreading (no-spread), so characteristicValue must be modified directly before writing.
    • Uniformly output hexadecimal strings for easier troubleshooting: BleCommand.toHexString(...)
  • Command Construction:
    • Read Status: entry/src/main/ets/utils/BleCommand.ets
    • Synchronize Time: entry/src/main/ets/utils/BleCommand.ets
    • Infusion Command: entry/src/main/ets/utils/BleCommand.ets (dose × 1000 converted to an integer, written in little-endian).
  • Synchronize Time: entry/src/main/ets/utils/BleService.ets, writes 0xA7 containing year, month, day, week, hour, minute, and second, then verifies through the notification channel upon completion.
  • Read Status: entry/src/main/ets/utils/BleService.ets → Wait for notification → Parse: entry/src/main/ets/utils/BleResponseParser.ets
    • Parses battery status, voltage/charge, remaining dose, single/daily limits, alarm bits, today’s usage, maximum log entries, etc.
  • entry/src/main/ets/utils/BleService.ets calls buildInjectionCommand(dose).
  • entry/src/main/ets/utils/BleCommand.ets: The dose is encoded as a 4-byte little-endian integer with a precision of 1/1000, accommodating “large/high-precision dose” scenarios.
  • Recommendations:
    • Perform pre-validation against the single/daily limits from the status, and split into packets or send in multiple parts if necessary.
    • Pay attention to MTU (typically 20 bytes) limitations and command length design.
  • Notification Handling Dispatch: entry/src/main/ets/utils/BleService.ets processReceivedData(...)
    • The “ path calls record parsing: entry/src/main/ets/utils/BleResponseParser.ets parseRecord(...)
    • Supports two types of structured data: injection records and operation records.
  • If you need to “fetch historical records by index/type,” you can add a READ_RECORD_WITH_TYPE constructor in BleCommand (a template is commented out in the project), which seamlessly integrates with the parsing logic above.

Summary Document: docs/ble-arkts-fix-summary.md

  • Missing Class Properties:
    • For example, if connectionPromiseResolvers is not declared, it needs to be added as Map<string, () => void> for external resolution of connection Promises.
  • arkts-no-spread:
    • Object spreading is forbidden when writing characteristic values. Directly modify existing.characteristicValue = ... (see the BleService.ets section).
  • unknown/any and Loose Literals:
    • In notification callbacks, remove temporary Record<string, string>/unknown assertions and use strong typing instead.
  • Notification Matching and Logging:
    • Use lowercase UUID comparison and detailed logging of service/char UUID and hexadecimal payloads for easier on-site debugging.

These fixes, without changing business semantics, make the code satisfy both ArkTS semantics and Lint rules, resulting in a stable and maintainable build.

  • Device Discovery and Caching:
    • entry/src/ohosTest/ets/test/BleDiscoveryService.test.ets
    • entry/src/ohosTest/ets/test/DeviceCache.test.ets
  • Coverage Points:
    • Scan status flow, filtering by name, RSSI sorting, automatic stopping.
    • Trusted device marking, cache clearing, capacity limits, expiration statistics, etc.
  • Running Tests:
    • hvigor test
    • Filter by file: hvigor test --filter BleDiscoveryService

2. Behavior-Driven Development (BDD) and UI Integration

Section titled “2. Behavior-Driven Development (BDD) and UI Integration”
  • Scenario Use Case: entry/src/ohosTest/ets/test/BleUIIntegration.test.ets
    • Start → Begin Scan → Discover Device → Connect → Sync Time/Refresh Status/Send Infusion → Disconnect.
    • Utilizes @kit.TestKit’s Driver to find buttons, click, and assert, ensuring an end-to-end path “from UI to protocol.”
  • Running Tests:
    • Full integration test: hvigor test --integration
  • Most BLE steps are asynchronous callbacks: set reasonable timeouts for scanning/connecting/writing/notifications (e.g., 5–15s) to avoid false positives.
  • For critical UI text and buttons, try finding them multiple times to improve stability.
  • Use hexadecimal logs as an assertion aid (see BleService.ets/BleService.ets).
  • Notification Order and “Warm-up”:
    • The sequence “subscribe → enable notifications → read once” can significantly improve the success rate of the first downstream response for some devices.
  • MTU and Command Length:
    • A typical BLE 4.2 MTU is only 20 bytes. Complex commands need to be split or the negotiation strategy on the device/firmware side needs to be upgraded.
  • Little-Endian Encoding and CRC:
    • The total command length, field encoding, and CRC16 (CCITT/False) calculation must be strictly aligned with the firmware.
  • Use HiLog Instead of console:
    • Use a unified domain/tag and %{public} output (see docs/hilog-migration-summary.md) for easier offline and on-site troubleshooting.
  • Permissions and Bluetooth Status:
    • Unified entry point: entry/src/main/ets/utils/BlePermissionManager.ets ensureBleReady(...). Handle permissions and adapter status all at once before starting a scan.

Thanks to Claude Code’s “code navigation + compilation repair + test generation” features, we completed the entire cycle from protocol design to an end-to-end working solution with minimal back-and-forth:

  • Bluetooth Interaction: The full chain of scanning, connecting, notifications, commands, and record parsing is connected.
  • ArkTS Fixes: Strictly follows semantics and Lint rules for a stable build.
  • TDD/BDD: Unit and UI integration tests cover major scenarios, facilitating continuous regression.

Recommended Next Steps:

  • Add the READ_RECORD_WITH_TYPE command constructor in BleCommand to integrate with the existing parser and complete the “fetch logs by index” feature.
  • Introduce more granular ViewModel layer state management and data persistence to create a complete “cloud-device-edge” loop with record synchronization.
  • Refine exception codes and retry strategies to enhance robustness during network disconnection/reconnection.

Claude Code Automates Migration to HarmonyOS BLE v15+ for Multi-Scan and Connection Management

The HarmonyOS BLE API version used in my previous project (v14 and earlier) had limitations such as single-scan restrictions and incomplete resource management.

Now, using Claude Code to generate and modify code, I was able to understand and automatically migrate to the latest HarmonyOS BLE API v15+, enabling multi-scan and more robust connection management.

Finally, I documented the complete migration process from v14 to v15+, focusing on multi-scan support, advertising data parsing, and connection management optimization.

In the HarmonyOS ecosystem, BLE (Bluetooth Low Energy) is a crucial technology for interconnecting smart devices. As application demands have grown, the limitation of single-scan has become increasingly apparent, especially in scenarios requiring simultaneous scanning for multiple devices or services.

HarmonyOS introduced multi-scan support in API version 15, allowing applications to create multiple independent scanning instances, thereby improving resource management and scanning flexibility.

However, the existing project code was still based on the old API, leading to the following issues:

  1. Single-Scan Limitation: Only one scanning task could be performed at a time, failing to meet the demand for multi-device scanning.
  2. Incomplete Resource Management: Scanner instances were not managed independently, causing state confusion.
  3. Lack of Advertising Data Parsing: Scan results did not parse advertising data, affecting device information retrieval.
  4. Simple Connection Management: The absence of retry and automatic reconnection mechanisms compromised connection stability.

Based on the latest HarmonyOS BLE API v15+, refactor the existing BLE service code to achieve the following goals:

  1. Multi-Scan Support: Allow multiple scanning tasks to run simultaneously, with each task managed independently.
  2. Independent Resource Management: Each scanner instance is controlled independently to avoid conflicts.
  3. Complete Advertising Data Parsing: Implement parsing of BLE advertising data.
  4. Enhanced Connection Management: Implement connection retry and automatic reconnection mechanisms to improve connection stability.
  5. Modern Asynchronous Handling: Use Promise/async-await to handle asynchronous BLE operations.

Before starting the migration, the first step was to download the official documentation to let Claude Code understand the new features and changes in HarmonyOS BLE API v15+.

2. Use Claude Code to Generate Migration Suggestions

Section titled “2. Use Claude Code to Generate Migration Suggestions”

I provided the official documentation content to Claude Code and asked it to analyze the problems in the existing code and execute the steps to migrate to the latest API.

Terminal window
> @harmony-os-docs/cn/doc/harmonyos-guides/ble-development-guide.md Recommend using the scanning method supported from API version
15, which allows applications to initiate and manage multiple scans. Do not use the scanning method supported in API version
14 and earlier, which only supports single-path scanning.
Read harmony-os-docs/cn/doc/harmonyos-guides/ble-development-guide.md (806 lines)
I understand. This document highlights important updates for HarmonyOS BLE development:
Key Points
API Version Upgrade Recommendation:
- Recommended: Use the multi-scan method from API version 15+
- Avoid: The single-scan method from API version 14 and earlier
Main Differences
API v15+ (Recommended)
// Create an independent scanner instance, supporting multi-scan management
let bleScanner: ble.BleScanner = ble.createBleScanner();
// Subscribe to scan results
bleScanner.on('BLEDeviceFind', onReceiveEvent);
// Start scanning
bleScanner.startScan([scanFilter], scanOptions);
// Stop scanning
bleScanner.stopScan();
Advantages:
- Supports concurrent multi-scanning
- Each scanner instance is managed independently
- More flexible resource control
- Better scan isolation
API v14 and earlier (Not Recommended)
// Global singleton scan, only supports single-path
ble.on('BLEDeviceFind', onReceiveEvent);
ble.startBLEScan([scanFilter], scanOptions);
ble.stopBLEScan();
Limitations:
- Only supports single-path scanning
- Complex global state management
- Cannot manage multiple scanning tasks simultaneously
Implementation Suggestions
Based on the example code in the documentation (BleScanManager class), it is recommended that the project adopt the following architecture:
1. Use BleScanner instance management: Create an independent BleScanner instance for each scanning task
2. Encapsulate a scan manager: Like the BleScanManager class in the documentation, to uniformly manage the scanning lifecycle
3. Complete advertising data parsing: Implement full parsing of BLE advertising data
4. Asynchronous operation handling: Use Promise/async-await to handle asynchronous BLE operations
This upgrade is particularly important for HarmonyOS projects, as applications may need to scan multiple devices or perform different types of scanning tasks simultaneously.
I will refactor BleService.ets based on the latest specifications of HarmonyOS API v15+ to implement multi-scan management and a more modern BLE operation architecture.
Code Analysis
The existing BleService.ets has the following key issues:
1. Use of deprecated API v14 single-scan: Uses ble.startBLEScan() and ble.on('BLEDeviceFind')
2. Lack of BLE advertising data parsing: Does not parse advertising data from scan results
3. Incomplete resource management: Scanner instances are not managed independently
4. Simple error handling: Lacks fine-grained error recovery mechanisms
...
'''
### 3. Generate Migration Code
Based on the analysis, Claude Code generated new `BleService.ets` code, including support for multi-scanning, advertising data parsing, and enhanced connection management.
```typescript
481
482 // Pending response callbacks
483 private pendingCallbacks: Map<string, (data: ArrayBuffer) => void> = new Map();
484 +
485 + /**
486 + * Clean up scanner resources
487 + */
488 + private cleanupScanner(scanId: string): void {
489 + // Clear timer
490 + const timer = this.scanTimers.get(scanId);
491 + if (timer) {
492 + clearTimeout(timer);
493 + this.scanTimers.delete(scanId);
494 + }
495 +
496 + // Remove from active set
497 + this.activeScanners.delete(scanId);
498 +
499 + // Clean up scanner instance
500 + this.bleScanners.delete(scanId);
501 + this.scanCallbacks.delete(scanId);
502 + }
503 +
504 + /**
505 + * Set up periodic cleanup of stale discovered devices
506 + */
507 + private setupDeviceCleanupTimer(): void {
508 + setInterval(() => {
509 + const now = Date.now();
510 + const staleThreshold = 60000; // 60 seconds
511 +
512 + for (const [deviceId, lastSeen] of this.deviceLastSeenTime.entries()) {
513 + if (now - lastSeen > staleThreshold) {
514 + // Remove stale devices not connected
515 + if (!this.connectedDevices.has(deviceId)) {
516 + this.discoveredDevices.delete(deviceId);
517 + this.deviceLastSeenTime.delete(deviceId);
518 + hilog.info(DOMAIN, TAG, `Removed stale device: ${deviceId}`);
519 + }
520 + }
521 + }
522 + }, 30000); // Run every 30 seconds
523 + }
524 +
525 + /**
526 + * Get all discovered devices (including non-connected)
527 + */
528 + public getDiscoveredDevices(): BleDevice[] {
529 + return Array.from(this.discoveredDevices.values());
530 + }
531 +
532 + /**
533 + * Get active scanner IDs
534 + */
535 + public getActiveScanners(): string[] {
536 + return Array.from(this.activeScanners);
537 + }
538 +
539 + /**
540 + * Create targeted scan for specific device
541 + */
542 + public async scanForDevice(
543 + deviceId: string,
544 + timeout: number = 10000
545 + ): Promise<BleDevice | null> {
546 + return new Promise((resolve, reject) => {
547 + const scanId = `targeted-${deviceId}-${Date.now()}`;
548 +
549 + this.startScan(
550 + scanId,
551 + (device) => {
552 + if (device.id === deviceId) {
553 + this.stopScan(scanId);
554 + resolve(device);
555 + }
556 + },
557 + { timeout }
558 + );
559 +
560 + // Set timeout for not finding device
561 + setTimeout(() => {
562 + if (this.activeScanners.has(scanId)) {
563 + this.stopScan(scanId);
564 + resolve(null);
565 + }
566 + }, timeout);
567 + });
568 + }
569 }

I conducted a detailed review of the generated code to ensure it met project requirements and performed comprehensive testing on actual devices to verify the stability of the multi-scan and connection management features.

Terminal window
$ hdc file send entry/build/default/outputs/ohosTest/entry-ohosTest-signed.hap "data/local/tmp/6a550b34422f402d80438c69110c772e"
$ hdc shell bm install -p data/local/tmp/6a550b34422f402d80438c69110c772e
$ hdc shell rm -rf data/local/tmp/6a550b34422f402d80438c69110c772e
Running tests.
$ hdc shell aa test -b com.vibersparking.ble_test -m entry_test -s unittest OpenHarmonyTestRunner -s class BleServiceTest -s timeout 15000
Started running tests.
Test finished.

Finally, I had Claude Code generate a complete summary document, recording the entire process of migrating from HarmonyOS BLE API v14 to v15+, including multi-scan support, advertising data parsing, and enhanced connection management features.

FeatureAPI v14 and earlierAPI v15+
Scanning MethodSingle-scan (global)Multi-scan (instantiated)
Scanner Managementble.startBLEScan()ble.createBleScanner()
Scan Eventble.on('BLEDeviceFind')bleScanner.on('BLEDeviceFind')
Stop Scanningble.stopBLEScan()bleScanner.stopScan()
Resource ManagementGlobal stateIndependent instance management
  • Concurrent Multi-Scanning: Supports running multiple scanning tasks simultaneously
  • Independent Resource Management: Each scanner is controlled independently, avoiding conflicts
  • Better Error Isolation: Failure of a single scan does not affect other scans
  • Flexible Filter Configuration: Each scan can have its own independent filter conditions
export class BleService {
// API v15+ scanner management
private bleScanners: Map<string, ble.BleScanner> = new Map();
private activeScanners: Set<string> = new Set();
private scanCallbacks: Map<string, (device: BleDevice) => void> = new Map();
private scanTimers: Map<string, number> = new Map();
// Device cache management
private discoveredDevices: Map<string, BleDevice> = new Map();
private deviceLastSeenTime: Map<string, number> = new Map();
// Connection management
private autoReconnectDevices: Set<string> = new Set();
private connectionRetryCount: Map<string, number> = new Map();
}
public startScan(
scanId: string,
callback: (device: BleDevice) => void,
options?: BleStartScanOptions
): void {
// Check for scan ID uniqueness
if (this.activeScanners.has(scanId)) {
hilog.warn(DOMAIN, TAG, `Scanner ${scanId} already active`);
return;
}
try {
// Create an independent scanner instance (API v15+)
const bleScanner = ble.createBleScanner();
this.bleScanners.set(scanId, bleScanner);
this.scanCallbacks.set(scanId, callback);
// Configure scan filters
const scanFilters: ble.ScanFilter[] = [];
if (options?.filterServiceUuid) {
scanFilters.push({
serviceUuid: SERVICE_UUID
});
}
// Subscribe to scan results
bleScanner.on('BLEDeviceFind', (scanReport: ble.ScanReport) => {
this.onDeviceFoundV15(scanId, scanReport);
});
// Start scanning
bleScanner.startScan(scanFilters, scanOptions);
this.activeScanners.add(scanId);
// Set auto-stop timer
const timeout = options?.timeout || SCAN_TIMEOUT_MS;
const timer = setTimeout(() => {
if (this.activeScanners.has(scanId)) {
this.stopScan(scanId);
}
}, timeout);
this.scanTimers.set(scanId, timer);
} catch (error) {
this.cleanupScanner(scanId);
throw error;
}
}
export class BleAdvertisingParser {
public parse(data: ArrayBuffer): ParsedAdvertisingData {
const result: ParsedAdvertisingData = {
serviceUuids: [],
serviceSolicitationUuids: [],
serviceData: new Map(),
manufactureSpecificData: new Map(),
rawData: data
};
const advData = new Uint8Array(data);
let position = 0;
while (position < advData.byteLength) {
const length = advData[position++];
if (length === 0) break;
const type = advData[position++];
const dataLength = length - 1;
const dataStart = position;
switch (type) {
case AdvertisingDataType.FLAGS:
result.flags = advData[dataStart];
break;
case AdvertisingDataType.LOCAL_NAME_COMPLETE:
result.localName = this.parseString(advData, dataStart, dataLength);
break;
case AdvertisingDataType.SERVICE_UUID_16_COMPLETE:
this.parseServiceUuids(advData, dataStart, dataLength, 2, result.serviceUuids!);
break;
case AdvertisingDataType.MANUFACTURER_SPECIFIC_DATA:
this.parseManufacturerData(advData, dataStart, dataLength, result.manufactureSpecificData!);
break;
}
position += dataLength;
}
return result;
}
}
public async connectDevice(
deviceId: string,
options?: BleConnectOptions
): Promise<void> {
const timeout = options?.timeout || CONNECTION_TIMEOUT_MS;
const retryCount = options?.retryCount || 3;
const autoReconnect = options?.autoReconnect !== false;
// Implement retry logic
let lastError: Error | null = null;
for (let attempt = 1; attempt <= retryCount; attempt++) {
try {
await this.connectWithTimeout(deviceId, timeout);
if (autoReconnect) {
this.autoReconnectDevices.add(deviceId);
}
return; // Success
} catch (error) {
lastError = error as Error;
if (attempt < retryCount) {
// Exponential backoff retry
const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
await this.delay(delay);
}
}
}
throw new Error(`Failed to connect after ${retryCount} attempts: ${lastError?.message}`);
}
// Add new interface definitions
interface BleStartScanOptions {
timeout?: number;
filterServiceUuid?: boolean;
filterManufacturerId?: boolean;
}
interface BleConnectOptions {
timeout?: number;
retryCount?: number;
autoReconnect?: boolean;
}

Old Code (v14):

ble.startBLEScan([scanFilter], scanOptions);
ble.on('BLEDeviceFind', (devices: Array<ble.ScanResult>) => {
this.onDeviceFound(devices);
});

New Code (v15+):

const bleScanner = ble.createBleScanner();
bleScanner.on('BLEDeviceFind', (scanReport: ble.ScanReport) => {
this.onDeviceFoundV15(scanId, scanReport);
});
bleScanner.startScan([scanFilter], scanOptions);
private cleanupScanner(scanId: string): void {
// Clear timer
const timer = this.scanTimers.get(scanId);
if (timer) {
clearTimeout(timer);
this.scanTimers.delete(scanId);
}
// Remove active scanner
this.activeScanners.delete(scanId);
// Clean up scanner instance
this.bleScanners.delete(scanId);
this.scanCallbacks.delete(scanId);
}
private setupDeviceCleanupTimer(): void {
setInterval(() => {
const now = Date.now();
const staleThreshold = 60000; // 60 seconds
this.deviceLastSeenTime.forEach((lastSeen, deviceId) => {
if (now - lastSeen > staleThreshold) {
if (!this.connectedDevices.has(deviceId)) {
this.discoveredDevices.delete(deviceId);
this.deviceLastSeenTime.delete(deviceId);
}
}
});
}, 30000);
}
const bleService = BleService.getInstance();
// Start scanning
bleService.startScan(
'scan-1',
(device) => {
console.log(`Found device: ${device.name}`);
},
{
timeout: 30000,
filterServiceUuid: true
}
);
// Scan for a specific service
bleService.startScan('service-scan', callback1, {
filterServiceUuid: true
});
// Scan for a specific manufacturer
bleService.startScan('manufacturer-scan', callback2, {
filterManufacturerId: true
});
// General scan
bleService.startScan('general-scan', callback3, {
timeout: 60000
});
// Connect with retry and auto-reconnect
await bleService.connectDevice(deviceId, {
timeout: 10000,
retryCount: 3,
autoReconnect: true
});
// Listen for connection state changes
bleService.addConnectionStateListener(deviceId, (state, prevState) => {
console.log(`Connection state changed: ${prevState} -> ${state}`);
});
  1. Scan Management

    • Assign a unique ID to each scanning task
    • Set a reasonable timeout
    • Clean up unnecessary scanners promptly
  2. Device Cache

    • Implement an expiration mechanism to avoid memory leaks
    • Retain information about recently discovered devices
    • Support quick reconnection
  3. Error Handling

    • Implement a retry mechanism
    • Use an exponential backoff strategy
    • Provide detailed error logs
  4. Resource Optimization

    • Avoid duplicate scanning
    • Set scanning parameters reasonably
    • Release GATT clients promptly
  1. Scanning Optimization

    const scanOptions: ble.ScanOptions = {
    interval: 0, // No delay reporting
    dutyMode: ble.ScanDuty.SCAN_MODE_LOW_LATENCY, // Low latency mode
    matchMode: ble.MatchMode.MATCH_MODE_AGGRESSIVE // Aggressive matching
    };
  2. Connection Optimization

    • Implement a connection pool
    • Cache discovered services in advance
    • Batch process notification data
  3. Memory Management

    • Periodically clean up expired devices
    • Limit cache size
    • Avoid memory leaks
  1. No Scan Results

    • Check Bluetooth permissions
    • Verify that Bluetooth is enabled
    • Confirm that filter conditions are correct
  2. Connection Failed

    • Increase the number of retries
    • Extend the timeout period
    • Check if the device is in range
  3. Resource Leaks

    • Ensure all scanners are cleaned up
    • Close GATT clients correctly
    • Clean up event listeners

The API v15+ upgrade brings significant improvements:

  • ✅ Supports concurrent multi-scanning
  • ✅ Independent resource management
  • ✅ Better error isolation
  • ✅ Flexible configuration options
  • ✅ Enhanced stability

By following this guide, you can smoothly migrate from v14 to v15+, taking full advantage of the new API to provide a more stable and efficient BLE connection experience.

Build a WeChat Chat Daily Report with Claude Code: chatlog + MCP in 3 Steps

Turn yesterday’s group and private chats into a one‑click daily report: top keywords, key people, to‑dos, and risk alerts — fully automated.
This guide walks you through using Claude Code + chatlog to squeeze insights from chat data, with copy‑paste‑ready prompts.


  • End‑to‑end flow: export/decrypt → start HTTP → connect to Claude Code (MCP) → one‑click daily report
  • Prompt templates: ready to copy for data fetch, analysis/aggregation, and report generation (Markdown/HTML/images)
  • Best practices: keyword radar, sensitive‑term alerts, to‑do extraction, sentiment curve
  • Pitfall checklist: keys, SIP, remote/local connectors, CSV/audio

chatlog is an open‑source tool that supports local WeChat database access, automatic decryption, HTTP API, Webhook, and MCP Streamable HTTP, so Claude Code can use it directly as a “data tool”.


Terminal window
# Install (choose one)
go install github.com/sjzar/chatlog@latest
# Or download a prebuilt binary from Releases

In the TUI, select Decrypt Data → Start HTTP Service (default http://127.0.0.1:5030).
API examples:

GET /api/v1/chatlog?time=2025-09-17&talker=wxid_xxx&format=json
GET /api/v1/contact
GET /api/v1/session

Supports YYYY-MM-DD or YYYY-MM-DD~YYYY-MM-DD windows; format supports json/csv/text.

Tip: First obtain the data key/image key. On macOS, you may need to temporarily disable SIP to extract keys (re‑enable afterwards).

2) Expose chatlog to Claude Code as an MCP server

Section titled “2) Expose chatlog to Claude Code as an MCP server”

chatlog natively supports MCP Streamable HTTP. Once HTTP is running, the endpoint is:

GET http://127.0.0.1:5030/mcp

Add a remote MCP in Claude Code:

Terminal window
# Syntax from the official example: claude mcp add --transport http <name> <url>
claude mcp add --transport http chatlog http://127.0.0.1:5030/mcp

Then in Claude Code, use /mcp to manage and use tools.

MCP is an open standard by Anthropic with Streamable HTTP transport and OAuth/Token auth, making it easy to plug external data into AI assistants.

Note: Remote MCP support is being rolled out. You can also use local STDIO. Capabilities depend on your account and version.


2. A low‑friction daily report structure (Claude can generate it directly)

Section titled “2. A low‑friction daily report structure (Claude can generate it directly)”
  • Today’s overview: total messages, active sessions, top groups/DMs, peak hours
  • Keyword radar: TF‑IDF/key phrases/topic clustering (merge synonyms)
  • Task extraction: a to‑do list triggered by phrases like “tomorrow/tonight/please/help me/to‑do/schedule”
  • Risk alerts: custom sensitive/compliance term hits with counts and context
  • Sentiment curve: hourly distribution (positive/neutral/negative) with anomalous peaks highlighted
  • High‑value snippets: top 5 highest information‑density excerpts (with session name/timestamp/message ID)
  • Appendix: raw data links (APIs can deep‑link to decrypted images/files/audio streams)

3. Claude Code prompts (copy‑paste ready)

Section titled “3. Claude Code prompts (copy‑paste ready)”

Usage: replace variables in {}; paste directly into Claude Code.
Below includes the recommended MCP approach and an HTTP‑only fallback (curl/script).

You are now connected to an MCP server: name=chatlog, endpoint=http://127.0.0.1:5030/mcp.
1) List all tools/resources provided by chatlog and briefly describe their purpose.
2) Check whether it can query chat logs, contacts, session lists, and media access.
3) If there are pagination/limit parameters, tell me the defaults and maximums.

B. Fetch all messages from yesterday (grouped by session)

Section titled “B. Fetch all messages from yesterday (grouped by session)”
Goal: Generate the “WeChat Chat Daily Report ({date})”.
Data fetch requirements:
- Date range: {date} 00:00:00 ~ {date} 23:59:59 (local timezone)
- Fetch up to {per_chat_limit} per session, up to {global_limit} overall
- Fields: time, talker, isChatRoom, sender, content, type, subType
- If a message has media (image/file/audio), record an accessible URL
Actions:
- Call chatlog’s tool/HTTP API: /api/v1/chatlog?time={date}~{date}&format=json&limit={global_limit}
- On failure, retry 2 times and record failed sessions
- Aggregate results by session ID; summarize per‑session message counts and an activity histogram
Output: generate data.json (containing raw and aggregated data)

(API shape per README; chatlog dynamically decrypts/serves media as accessible paths.)

For data.json:
1) Perform Chinese tokenization + stopword removal + synonym merging (e.g., “OK/好的/行/可以” consolidated).
2) Output the top 20 keywords (weights, example sentences, and the sessions where they frequently appear).
3) Using rules + LLM, extract to‑dos (owner, action verb, due time, context link).
4) Maintain a sensitive term list (I’ll supply) and produce hit counts with a ±3‑sentence context window.
Outputs: keywords.json, todos.json, alerts.json
Assign a coarse sentiment label (positive/neutral/negative) to each message and aggregate by hour into a curve.
Detect anomalous peaks (e.g., >3σ) and list the sessions and key snippets responsible.
Outputs: sentiment_by_hour.csv, peaks.md (with explanations)

E. Generate the report (Markdown + HTML + images)

Section titled “E. Generate the report (Markdown + HTML + images)”
Assemble {keywords.json, todos.json, alerts.json, sentiment_by_hour.csv} into the “Chat Daily Report ({date})”.
Layout:
- Today’s overview (include a data table)
- Keyword radar (word cloud + one‑line summary per term)
- To‑do list (owner/due/link)
- Risk alerts (term/count/context jump)
- Sentiment curve (line chart)
- Top 5 high‑value snippets (with session name/timestamp)
Requirements:
- First output Markdown (report.md), then render a minimalist HTML (report.html with inline styles)
- Images: generate two figures (word cloud, sentiment curve) in ./assets and reference in HTML
- Provide a final “one‑click copy” Markdown block

F. Quick HTTP‑only fallback (no MCP required)

Section titled “F. Quick HTTP‑only fallback (no MCP required)”
Terminal window
# Fetch yesterday’s data (JSON)
curl -G "http://127.0.0.1:5030/api/v1/chatlog" \
--data-urlencode "time=2025-09-17~2025-09-17" \
--data-urlencode "limit=5000" \
--data-urlencode "format=json" > data.json

API params and media decryption/serving are provided by chatlog.


4. Best practices: make the report smarter

Section titled “4. Best practices: make the report smarter”
  1. Synonym map: normalize common colloquialisms to reduce word‑cloud noise.
  2. To‑do extraction rules: regex + few‑shot tuned to phrases like “help me”, “remember to”, “by tonight”.
  3. Role profiling: score members by talk density/influence to spot “information sources”.
  4. Webhook increments: pair chatlog’s Webhook with your middleware to push deltas as new messages arrive.
  5. CSV/audio: recent versions improved CSV and audio pipelines — check the Releases Changelog.

  • Only process data you legally own. Respect privacy and platform terms; the project emphasizes this as well.
  • On macOS, obtaining keys may require temporarily disabling SIP; re‑enable afterwards.
  • Remote MCP support is rolling out; local STDIO is more stable. Check your account/version.
  • MCP connection syntax follows the official docs: claude mcp add --transport http <name> <url>.
  • MCP concepts/auth: use Streamable HTTP with standard auth for safer team deployments.

6. Advanced: portable sources & team sharing

Section titled “6. Advanced: portable sources & team sharing”
  • Deploy chatlog with Docker on a NAS and pre‑set CHATLOG_WEBHOOK_* env vars to integrate your toolchain.
  • Use Claude Connectors/MCP catalogs to manage multiple sources so non‑technical teammates can connect with a click.

Treat chats as data and use Claude Code to refine them into an actionable team daily.
Spend 3 minutes skimming each day and get time back for what actually matters.

Resolve Git Merge Conflicts with Claude Code

Using Claude Code to handle Git branch merges and resolve conflicts

In modern software development, Git merges and conflict resolution are everyday tasks. Claude Code, as an intelligent development assistant, can significantly speed up and harden these workflows. This post walks through practical scenarios showing how to use Claude Code to handle a variety of merge cases.

Claude Code’s strengths for Git operations:

  • Intelligent conflict analysis: identifies root causes and proposes optimal solutions
  • Batch operations: resolve conflicts across many files at once
  • Code‑semantic understanding: resolves based on logic, not just textual diffs
  • Automated verification: runs tests after merges to ensure correctness

Example 1: Feature Branch Merge with a Simple Conflict

Section titled “Example 1: Feature Branch Merge with a Simple Conflict”

You’re building a React app. The feature/user-auth branch implements user authentication and needs to be merged into main. Both branches modified App.tsx.

User: Please merge feature/user-auth into main and resolve any conflicts.
Claude Code:
Let me help you complete the merge. First, I’ll check the current state:
[run git status and git branch -a]
[run git checkout main]
[run git pull origin main]
[run git merge feature/user-auth]
Found a conflict in src/App.tsx. Analyzing the conflict:
Conflict region:
- main branch: added a new navigation component
- feature/user-auth: added an authentication wrapper
These changes are complementary. I’ll keep both:
[auto-edit App.tsx, semantically integrating both changes]
[run git add src/App.tsx]
[run npm test to verify]
[run git commit]
Merge complete! All tests passed. The new App.tsx includes both navigation and authentication.
  • Detects complementary vs. mutually exclusive changes
  • Semantically integrates code instead of naïve text splicing
  • Automatically runs tests to validate the merge

Example 2: Multi‑File Conflicts with Cross‑Dependency Changes

Section titled “Example 2: Multi‑File Conflicts with Cross‑Dependency Changes”

In a Node.js microservice, feature/database-migration updates the DB schema while main adds new API endpoints. Conflicts span multiple files and dependencies.

User: Merge feature/database-migration into main. This branch changes DB models.
Claude Code:
I’ll handle this systematically. First, scope the impact:
[run git diff main...feature/database-migration --name-only]
Potential conflicts detected:
- package.json (dependency version conflicts)
- src/models/User.js (model structure changes)
- src/controllers/UserController.js (API logic conflict)
- migrations/20240315_user_table.sql (migration script)
Proceeding with merge resolution:
1) package.json dependencies:
- Keep newer mongoose: ^7.0.3
- Merge in the migration tool dependency
[auto-edit package.json]
2) User model conflict:
- Integrate new fields
- Update validation rules
- Maintain backward compatibility
[semantic refactor of User.js]
3) Update UserController to fit the new model:
- Adjust query logic
- Update response shapes
[auto-edit controller code]
4) Validate migration scripts:
- Ensure correct ordering
- Add rollback script
[create supplemental migration file]
[run npm install]
[run npm run migrate]
[run npm test]
All conflicts resolved and tests passed. Recommend integration testing before deployment.
  • Handles cross‑file dependencies and ripple effects
  • Identifies related files that must change together
  • Generates necessary migration and rollback scripts

Example 3: Emergency Hotfix Merge and Bug Repair

Section titled “Example 3: Emergency Hotfix Merge and Bug Repair”

There’s a production critical bug. hotfix/payment-calculation contains a fix, but conflicts with develop. It needs to be merged into both main and develop.

User: Urgent! Merge hotfix/payment-calculation into main and develop. It fixes a severe payment calc bug.
Claude Code:
Understood — correctness first.
Phase 1: Merge into main (production)
[run git checkout main]
[run git merge --no-ff hotfix/payment-calculation]
Conflict in src/services/PaymentService.js:
- hotfix fixes a formula error
- main has code formatting changes
Keep the fix and apply formatting:
[semantic merge; retain fix, apply formatting]
Validate the fix:
[add targeted tests for the bug]
[run npm run test:payment]
Phase 2: Merge into develop (avoid regressions)
[run git checkout develop]
[run git merge hotfix/payment-calculation]
More complex conflict:
- develop is refactoring the payment module
- fix must be adapted to the new architecture
Adapt the fix to the new structure:
[analyze new module; transplant fix]
[update affected unit tests]
[add regression tests]
Phase 3: Verification and docs
[run full test suite]
[generate a fix report]
Fix successfully applied to both branches!
Summary of changes:
- Fixed floating‑point precision issue
- Introduced BigDecimal for monetary math
- Added boundary‑condition test coverage
Recommend immediate production deployment.
  • Prioritization and risk management for hotfixes
  • Porting fixes across different architectures
  • Autogenerated regression tests to prevent recurrence
User: Preview potential conflicts before merging.
Claude Code:
[run git merge --no-commit --no-ff feature/branch]
[analyze conflicts and propose resolutions]
[run git merge --abort to roll back preview]
User: For this file, which side should we keep?
Claude Code:
Based on code semantics and test coverage, I suggest:
- API route files: keep both (additive features)
- Config files: prefer the feature branch (new options)
- Stylesheets: manual review recommended (visual impact)
Claude Code automatically runs:
- static analysis
- unit tests
- integration tests
- coverage checks
- performance benchmarks

Claude Code will detect binary files and offer:

  • keep a specific version
  • regenerate the file
  • manually choose the version
Supported options:
- git reset --hard HEAD~1 (if not pushed)
- git revert -m 1 <merge-commit> (if already pushed)
- automatically create a repair branch

Claude Code can:

  • detect version conflicts
  • suggest appropriate commit revisions
  • update .gitmodules
  1. Batch conflict resolution: resolve multiple files in parallel
  2. Smart merge strategies: choose by file type
  3. Leverage caching: use Git rerere to remember resolutions

Claude Code turns Git merging from a tedious manual process into a smarter, automated workflow. With semantic understanding, automated testing, and intelligent conflict resolution, it improves both developer efficiency and code quality.

Key advantages:

  • Up to 80% less time spent on conflicts
  • Automated tests guard merge quality
  • Smart suggestions avoid common mistakes
  • Complete, reviewable operation history

In production projects, integrate Claude Code into CI/CD for even more automation. While Claude Code is powerful, architectural decisions should still be reviewed by humans.

Smart APK Naming for Flutter Android Builds with Claude Code

Make APKs readable at a glance: channel, environment, version, branch, timestamp — no manual renaming.

Let Claude Code inject the naming rule into android/app/build.gradle. Every build outputs a descriptive filename.

Example output: TestAApp-release-v1.0+1-main-20250918-102530.apk Includes: app name + build type + version name/code + git branch + timestamp.

— Official Flutter build paths and Gradle references are listed at the end.


Use Claude Code: one prompt to patch build.gradle

Section titled “Use Claude Code: one prompt to patch build.gradle”

Copy one of the prompts below into Claude Code.

Prompt: Quick Rename

You are an Android/Flutter build engineer. In my Flutter project’s
android/app/build.gradle (Groovy), please add:
1) getGitBranchName(): prefer `git rev-parse`, fallback to env GIT_BRANCH;
2) Parse -Pdart-defines (Base64 list from Flutter --dart-define) and decode to a Map;
3) Generate APK name: {AppName}-{buildType}-v{versionName}+{versionCode}-{gitBranch}-{yyyyMMdd-HHmmss}.apk;
4) In the corresponding variant’s assemble task doLast, copy and rename the output;
5) Print a log: “Renamed APK generated: path/filename”.
Do not replace existing config; only append what’s required. Keep valid Groovy syntax.

Prompt: With Validation

Inspect my current android/app/build.gradle and AGP version:
- If setting outputFileName directly may not work, use the “copy-after-assemble” approach;
- Support multiple flavors/build types;
- Provide a minimal invasive patch and explain each added line.

Prompt: CI-Friendly

Enhance for GitHub Actions:
- If `git rev-parse` is unavailable, read `$GITHUB_REF_NAME` as the branch name;
- Place the new APK in {project}/android/app/build/outputs/apk/{buildType}/;
- Print the full path to stdout for later artifact upload steps.
Output only a final, runnable Groovy code block.

By default it’s app-release.apk. When sending to QA or uploading to CI artifacts, everything has the same name. It’s guesswork to identify versions — frustrating and error-prone.

With a descriptive name you immediately know:

  • Which branch produced it
  • Which version it is
  • When it was built

Productivity goes up immediately.


  • A standard Flutter/Android project.

  • Any Android Gradle Plugin (AGP) version works, but naming approaches differ. The robust approach is to copy/rename after assemble. That’s the path used below and is widely adopted under newer AGP APIs.

  • Flutter’s --dart-define values are passed via Gradle -Pdart-defines as Base64. We can decode and read them in build.gradle.


Copy and use: add this to android/app/build.gradle

Section titled “Copy and use: add this to android/app/build.gradle”

Place under the android { ... } section with applicationVariants (Groovy syntax). Idea: get branch name + decode --dart-define + build the new file name + copy/rename after assemble. This “copy and rename” technique is more reliable across AGP versions.

// Read git branch (fallbacks for CI)
def getGitBranchName() {
try {
def branch = "git rev-parse --abbrev-ref HEAD".execute().text.trim()
return (branch ?: System.getenv("GIT_BRANCH") ?: "unknown").replace('/', '-')
} catch (Exception e) {
return System.getenv("GIT_BRANCH") ?: "unknown"
}
}
android {
// ... your existing config ...
applicationVariants.all { variant ->
variant.outputs.all { output ->
// 1) Parse Flutter --dart-define (in Gradle as -Pdart-defines, Base64)
def dartDefinesMap = [:]
if (project.hasProperty('dart-defines')) {
def raw = project.property('dart-defines')
def entries = []
if (raw instanceof List) entries.addAll(raw)
else if (raw instanceof String) entries.addAll(raw.split(','))
entries.each { item ->
try {
def decoded = new String(item.decodeBase64())
def kv = decoded.split('=', 2)
if (kv.length == 2) dartDefinesMap[kv[0]] = kv[1]
} catch (Exception ignored) { }
}
}
// 2) Optional environment keys from dart-define
def appName = "TestAApp"
def buildType = variant.buildType.name
def versionName = variant.versionName
def versionCode = variant.versionCode
def gitBranch = getGitBranchName()
def timestamp = new Date().format("yyyyMMdd-HHmmss")
def newApkName = "${appName}-${buildType}-v${versionName}+${versionCode}-${gitBranch}-${timestamp}.apk"
// 3) After assemble for this variant, copy and rename the artifact
variant.assembleProvider.get().doLast {
def outDir = output.outputFile.parent
copy {
from(output.outputFile)
into(outDir)
rename { newApkName }
}
println "✅ Renamed APK generated: $outDir/$newApkName"
}
}
}
}

Notes:

  • Local uses git rev-parse; CI can fallback to the GIT_BRANCH environment variable.
  • Newer AGP often breaks “rename in place”; copy+rename is the portable approach.
  • See Flutter docs for build configuration locations and packaging steps.

Command example:

Terminal window
# Release build (example env flags)
flutter build apk --release \
--dart-define=LOG_SHOW_PREFIX=false \
--dart-define=CHANNEL=official

Flutter encodes these --dart-define entries in Base64 and injects them as -Pdart-defines. The Gradle snippet above decodes them into a Map.


  • In‑place rename sometimes fails New AGP Variant APIs changed. Community practice favors “copy + rename after assemble”.

  • Flutter output directory quirks Some builds land under flutter-apk/ or ignore outputFileName. Use the copy+rename fallback.

  • CI with detached HEAD git rev-parse can’t read the branch. Use env fallback (GIT_BRANCH or CI‑specific vars).


Terminal window
flutter build apk --release \
--dart-define=LOG_SHOW_PREFIX=false \
--dart-define=CHANNEL=official
# Output like:
# android/app/build/outputs/apk/release/TestAApp-release-v1.0+1-main-20250918-102530.apk

Compare with the official documentation for build entry points and directory structure.


Bake the naming rule into the build step so every artifact is self‑describing. QA hand‑off, tracebacks, and bug hunts all get easier. Claude Code turns these “small but annoying” chores into a one‑time setup you can reuse.

Anything else you want included in the name? For example, short git hash, channel, target ABI?


  1. Rename APKs the Smart Way: Claude Code Automates Flutter Android File Names slug: smart-apk-naming-with-claude-code

  2. One‑Click APK Renaming with Version, Branch and Timestamp slug: one-click-flutter-apk-rename

  3. Stop Shipping app-release.apk: Make Releases Self‑Describing slug: stop-shipping-app-release-apk


Cover and illustration prompts (2:1, no text)

Section titled “Cover and illustration prompts (2:1, no text)”

Cover prompt: “Flat illustration, dev workspace at night, laptop building Android app, APK file icon morphs into a labeled package showing version, branch, timestamp, gentle neon lights, clean vector shapes, 2:1.”

Illustration #1 (where the code goes): “Diagram‑style illustration, build.gradle file with highlighted code blocks, arrows from git branch and dart‑define to ‘new APK name’, minimalistic, vector, 2:1.”

Illustration #2 (pipeline scene): “CI/CD conveyor belt turning generic app-release.apk into descriptive files with tags (release, v1.0+1, main, 20250918), playful but professional, vector, 2:1.”


  1. “Everything used to be app-release.apk — I’d install the wrong build all the time. Now the file name carries version/branch and I never guess. 😎”
  2. “No time to read? Paste the prompts into Claude Code. In 5 minutes your Gradle is set up and you save half a day of back‑and‑forth.”
  3. “QA no longer asks ‘who built this and where did it come from?’. The name tells the story. Communication cost = 0.”

References:

Claude Code + ArkTS for HarmonyOS: Build a BLE Manager in Minutes

Use Claude Code as your “pair programmer who knows HarmonyOS ArkTS” to build a BLE manager that can scan / connect / read-write / subscribe — runnable on a real device with logs for debugging.


Anyone who has built a BLE manager knows: the protocol is fragmented, device vendors differ wildly, and versions change fast. HarmonyOS/ArkTS docs are large and spread out — newcomers get lost easily. My practical approach: feed the official documentation into Claude Code and let it be a “code-with-the-manual-open” partner in the editor; we stay focused on business logic and debugging flow.

  • ArkTS is the preferred native language for HarmonyOS, enhancing TypeScript with stronger static checks and performance (see official docs: https://developer.huawei.com/consumer/cn/arkts/).
  • BLE on HarmonyOS uses @ohos.bluetooth.ble, with core capabilities for scanning, advertising, and GATT client/server.
  • Real data interaction goes via GATT: reading/writing characteristics and subscribing to notifications.

The benefit of this combo: fewer guesses and directly coding to the docs. Claude Code searches, cross-checks, and completes; you control architecture, state machine, and logging.


Preparation | Put the docs into Claude’s “stomach”

Section titled “Preparation | Put the docs into Claude’s “stomach””
  1. Goal context
    We’ll build an ArkTS app that connects to BLE devices.

  2. Download official docs and add a local folder
    Grab the ArkTS & BLE docs (guides + API references) from Huawei Developers, and store them offline in your project under /harmony-os-docs/.

  1. Write a CLAUDE.md (sample)
    Treat Claude Code as a teammate and require it to strictly consult these docs before generating ArkTS code and explanations:
# CLAUDE.md (excerpt)
You are my ArkTS + BLE copilot. Always quote and align with these docs:
### ArkTS
- @harmony-os-docs/cn/doc/harmonyos-guides/typescript-to-arkts-migration-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-coding-style-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-high-performance-programming.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-migration-background.md
- @harmony-os-docs/cn/doc/harmonyos-guides/arkts-more-cases.md
- @harmony-os-docs/cn/doc/harmonyos-guides/introduction-to-arkts.md
### BLE (HarmonyOS)
- @harmony-os-docs/cn/doc/best-practices/bpta-bluetooth-low-energy.md
- @harmony-os-docs/cn/doc/best-practices/bpta-reasonable-bluetooth-use.md
- @harmony-os-docs/cn/doc/harmonyos-guides/ble-development-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/br-development-guide.md
- @harmony-os-docs/cn/doc/harmonyos-guides/gatt-development-guide.md
Rules:
- Prefer ArkTS idioms and coding style.
- Cite doc path + section when uncertain.
- If API differs by version, note the min API level & capability.

The key here is to constrain Claude: if it’s unsure, check; if it’s uncertain, annotate. ArkTS style guidance and performance tips can be referenced directly in code review.


Permissions & abilities
Declare required permissions in entry/src/main/module.json5 (adjust per your API level/version):

  • ohos.permission.USE_BLUETOOTH (enable Bluetooth)
  • ohos.permission.DISCOVER_BLUETOOTH (scan/configure)
  • ohos.permission.LOCATION (location permission often required for scanning; follow UX requirements for foreground disclosure)

Module entry
ArkTS BLE uses @ohos.bluetooth.ble. Scan results come from ble.on('BLEDeviceFind', cb). After discovering a device, create GattClientDevice to connect and perform GATT read/write/subscribe.

The official “BLE best practices for scanning/connection state management” also provides suggestions for a business-layer state machine; consider persisting those.


Open Claude Code and ask it to implement:

Terminal window
> Write a `BleManager` class that can enable/scan/connect/read/write/subscribe/disconnect and exposes state + error callbacks.
Location: `entry/src/main/ets/utils/BleManager.ets`
Capabilities: enable/scan/connect/read/write/subscribe/disconnect/state management/key logs

Generated code

// entry/src/main/ets/utils/BleManager.ets
import ble from '@ohos.bluetooth.ble';
import { BusinessError } from '@ohos.base';
type Device = {
deviceId: string; // e.g., "XX:XX:XX:XX:XX:XX"
name?: string;
rssi?: number;
advData?: Uint8Array;
};
type ConnectionState = 'idle' | 'scanning' | 'connecting' | 'connected';
export class BleManager {
private static _i: BleManager;
static I() { return this._i ??= new BleManager(); }
private state: ConnectionState = 'idle';
private devices = new Map<string, Device>();
private gatt?: ble.GattClientDevice;
// Business-side subscriptions
onScan?: (list: Device[]) => void;
onState?: (s: ConnectionState) => void;
onNotify?: (opt: { service: string; characteristic: string; value: Uint8Array }) => void;
onError?: (e: { tag: string; err: unknown }) => void;
private setState(s: ConnectionState) {
this.state = s;
this.onState?.(s);
}
/** Start scanning */
async startScan() {
try {
if (this.state === 'scanning') return;
this.devices.clear();
// Listen for scan results (BLEDeviceFind returns a list of ScanResult)
ble.on('BLEDeviceFind', (results: Array<ble.ScanResult>) => {
for (const it of results ?? []) {
const id = it.deviceId;
this.devices.set(id, {
deviceId: id,
name: it.deviceName,
rssi: it.rssi,
advData: it.advData
});
}
this.onScan?.(Array.from(this.devices.values()));
});
// Start scanning (provide filters if needed)
await ble.startBLEScan(); // Some versions use ble.startScan(filters)
this.setState('scanning');
console.info('[BLE] scanning started');
} catch (err) {
this.onError?.({ tag: 'startScan', err });
}
}
/** Stop scanning */
async stopScan() {
try {
await ble.stopBLEScan();
ble.off('BLEDeviceFind'); // Unsubscribe
this.setState('idle');
console.info('[BLE] scanning stopped');
} catch (err) {
this.onError?.({ tag: 'stopScan', err });
}
}
/** Connect to device */
async connect(deviceId: string) {
try {
await this.stopScan().catch(() => {});
this.setState('connecting');
// Create GATT client and connect
this.gatt = ble.createGattClientDevice(deviceId);
await this.gatt.connect(); // Some versions return a Promise; others are callback-based
this.setState('connected');
console.info(`[BLE] connected: ${deviceId}`);
} catch (err) {
this.setState('idle');
this.onError?.({ tag: 'connect', err });
}
}
/** Read characteristic */
async read(serviceUuid: string, charUuid: string): Promise<Uint8Array | undefined> {
try {
if (!this.gatt) throw new Error('Gatt not ready');
const value: Uint8Array = await this.gatt.readCharacteristicValue({
serviceUuid, characteristicUuid: charUuid
} as any);
console.info(`[BLE] read ${serviceUuid}/${charUuid} -> ${value?.length ?? 0}B`);
return value;
} catch (err) {
this.onError?.({ tag: 'read', err });
}
}
/** Write characteristic (choose Write/Write NoRsp by need) */
async write(serviceUuid: string, charUuid: string, payload: Uint8Array, noRsp = false) {
try {
if (!this.gatt) throw new Error('Gatt not ready');
await this.gatt.writeCharacteristicValue({
serviceUuid,
characteristicUuid: charUuid,
value: payload,
writeType: noRsp ? 1 : 0 // Example: replace with actual enum
} as any);
console.info(`[BLE] write ${serviceUuid}/${charUuid} ${payload.length}B`);
} catch (err) {
this.onError?.({ tag: 'write', err });
}
}
/** Subscribe/unsubscribe notifications */
async subscribe(serviceUuid: string, charUuid: string, enable: boolean) {
try {
if (!this.gatt) throw new Error('Gatt not ready');
await this.gatt.setCharacteristicChangeNotification({
serviceUuid, characteristicUuid: charUuid, enable: enable
} as any);
if (enable) {
this.gatt.on('characteristicChange', (res: any) => {
const value: Uint8Array = res?.characteristic?.value ?? res?.value;
this.onNotify?.({ service: serviceUuid, characteristic: charUuid, value });
});
} else {
this.gatt.off('characteristicChange');
}
console.info(`[BLE] notify ${enable ? 'ON' : 'OFF'} for ${charUuid}`);
} catch (err) {
this.onError?.({ tag: 'subscribe', err });
}
}
/** Disconnect and cleanup */
async disconnect() {
try {
if (this.gatt) {
await this.gatt.disconnect();
this.gatt.close?.();
}
this.gatt = undefined;
this.setState('idle');
console.info('[BLE] disconnected');
} catch (err) {
this.onError?.({ tag: 'disconnect', err });
}
}
/** Device list & state */
getState() { return this.state; }
getDevices() { return Array.from(this.devices.values()); }
}

Why this structure?

  • Use the BLEDeviceFind event for scan results; remember to off when stopping.
  • Connect via createGattClientDevice(deviceId) + connect(), which matches official usage.
  • Interactions rely on GATT: read/write/subscribe (notifications). Method names/params vary by version; always defer to the API reference. The overall approach remains: identify service/characteristic → read/write/subscribe.
  • Unified error callbacks and key logs make packet capture and production debugging easier. Best practices emphasize “reasonable Bluetooth usage” and foreground/background policies.

Tip: If your peripheral uses a custom GATT profile, align the Service/Characteristic UUIDs and payload protocol up front — it makes the client side much smoother.


5 ways to get real productivity from Claude Code

Section titled “5 ways to get real productivity from Claude Code”
  1. Make it read docs first: include @harmony-os-docs/... paths in your prompt and ask for citations.
  2. Ask for a “design doc” up front: folder layout + state machine + event flow + key API mapping table.
  3. Call out version differences: require an “API version matrix”, e.g., startBLEScan vs startScan, and mark “verify on local SDK” where uncertain.
  4. Auto-generate tests/stubs: request quick cases with mocked callbacks/notifications, covering reconnect, permission denial, etc.
  5. Log protocol: agree on a [BLE] prefix + key fields for easy collection; follow “reasonable Bluetooth usage” best practices for scan window and frequency.

In short: feed Claude the docs and tell it to write ArkTS code by the book. You own the boundaries, state, and debugging. In an afternoon, you can have a runnable BLE manager. Thoughts? Share your device model and pitfalls in the comments — I can help with parameters and debugging strategies.

Anthropic (Claude Code’s Parent) Completes $10B Funding Round: An Analysis

Anthropic has emerged as a prominent player in artificial intelligence. Its core vision is to build AI systems that are trustworthy, interpretable, and controllable—and to lead a “safety‑first race.” Unlike many peers, Anthropic’s story did not begin with a single technical breakthrough but with a deep philosophical and governance split. From day one, it has treated AI safety and ethics as a foundational mission, embedding them into the company’s legal structure, technical methodology, and commercial strategy.

Part I: Origins of a Safety‑First Mission

Section titled “Part I: Origins of a Safety‑First Mission”

Born of a split: OpenAI’s philosophical rift

Section titled “Born of a split: OpenAI’s philosophical rift”

Anthropic was founded in 2021 by a group of former OpenAI employees, led by siblings Dario Amodei (former VP of Research at OpenAI) and Daniela Amodei (former VP of Safety and Policy). In late 2020, they left OpenAI with five colleagues due to fundamental disagreements over the company’s direction.

Dario and others were concerned about OpenAI’s 2019 transition from a non‑profit to a “capped‑profit” entity and its deep partnership with Microsoft. They believed this shift moved the mission from “benefiting all of humanity” toward commercialization and profit, relegating AI safety and ethics to a secondary role. As Dario put it, they “could foresee the exponential growth of artificial intelligence,” and AI companies urgently needed “a set of values to constrain these powerful programs.” The founding of Anthropic was a direct counter to what they saw as sacrificing safety for commercial priorities.

Public benefit corporation: writing the mission into the charter

Section titled “Public benefit corporation: writing the mission into the charter”

Anthropic is a Delaware public benefit corporation (PBC). This legal structure requires the company to balance shareholder interests with a public‑benefit purpose. For Anthropic, that purpose is to develop AI systems that are reliable, interpretable, and controllable.

To prevent commercial pressure from eroding its safety mission, Anthropic established the Long‑Term Benefit Trust, which holds a special T‑class of shares and can elect a majority of the board. This governance design aims to legally insulate the safety mission—at least in part—from purely financial interests, addressing the limitations of traditional corporate governance in confronting potential catastrophic risks from AGI.

From the founders’ departures to the company’s structural design, Anthropic’s core narrative is clear: rapid AI progress requires a mission‑driven governance paradigm. This not only builds a “responsible” brand but also offers a credible choice for those concerned about AGI’s commercialization risks.

Part II: Claude’s Architectural Philosophy

Section titled “Part II: Claude’s Architectural Philosophy”

Anthropic’s uniqueness lies not only in governance but in its technical methodology, centered on directly addressing the alignment problem.

Constitutional AI (CAI) aims to train AI to be “helpful, honest, and harmless.” Its core idea is to introduce a human‑written “constitution”—a set of principles that guide the model to self‑critique and revise its outputs during training. Unlike the common approach of deflecting or blurring sensitive topics, CAI enables more direct responses under principled constraints and requires the model to explain refusals when appropriate.

Training occurs in two stages. In supervised fine‑tuning, the model critiques and corrects its own problematic answers using constitutional principles, producing a “less harmful” dataset for further tuning.

Reinforcement learning from AI feedback (RLAIF): an engine for scalable alignment

Section titled “Reinforcement learning from AI feedback (RLAIF): an engine for scalable alignment”

The second stage uses reinforcement learning. Anthropic applies RLAIF: the model generates two candidate answers, then evaluates and selects a preferred one according to a randomly chosen constitutional principle; these judgments train a preference model so the final policy better adheres to the constitution.

Compared with the more common RLHF, Anthropic argues RLAIF is more efficient and scalable (less dependent on human labeling), improves interpretability and transparency by expressing goals in natural language, and somewhat reduces human bias. Critics note the constitution is still human‑written and thus subjective, and that reducing human intervention raises questions about accountability and oversight. The tension between “automation” and “human control” is central to understanding Anthropic’s approach.

Part III: Evolution of the Claude AI Series

Section titled “Part III: Evolution of the Claude AI Series”

From research to frontier models: a fast timeline

Section titled “From research to frontier models: a fast timeline”

Since launching Claude 1 in March 2023, Anthropic has iterated rapidly on a roughly 4–8 month cadence: Claude 2 (July 2023), the Claude 3 family (March 2024), and beyond—demonstrating that Anthropic is both a research organization and a product company competing at the frontier.

Each generation pushed forward on context length, reasoning, and multimodality: from Claude 2’s 100K‑token context window to Claude 3’s 200K, then toward ~1M tokens in extended reasoning modes with Claude 4. Starting with Claude 3, image+text is supported; coding, math, and logical reasoning improved markedly.

Tiered lineup: covering distinct use cases

Section titled “Tiered lineup: covering distinct use cases”

Beginning with Claude 3, Anthropic adopted a three‑tier lineup:

  • Haiku: fastest, for real‑time and low‑latency scenarios.
  • Sonnet: balanced performance/latency, for general tasks.
  • Opus: flagship, for complex tasks and advanced reasoning.

Claude 3.5 Sonnet (June 2024) surpassed the larger Claude 3 Opus on several benchmarks, signaling aggressive optimization and productization.

  • Artifacts: introduced with Claude 3.5 Sonnet; generates and previews code, SVGs, websites, and more in a dedicated pane.
  • Computer Use: debuted in 3.5 Sonnet beta; the AI can operate a virtual desktop, simulating cursor, clicks, and input across applications for multi‑step tasks.
  • Hybrid Dual‑Mode Reasoning: added in Claude 3.7 and Claude 4; dynamically switches between fast responses and “extended thinking,” invoking tools (retrieval, code execution) when needed.

These capabilities move AI from assistantship toward autonomous agency, while bringing AGI‑related risks closer to the real world.

Table 1: Release timeline and core capabilities of Claude

Section titled “Table 1: Release timeline and core capabilities of Claude”
ModelRelease dateKey capabilities/notes
Claude 1Mar 2023Initial launch; assistant prototype
Claude 2Jul 2023Industry‑leading 100K‑token context
Claude 3 family (Haiku, Sonnet, Opus)Mar 2024Tiered lineup; text+image; strong benchmarks
Claude 3.5 SonnetJun 2024Major gains in coding and chart analysis; introduced “Artifacts”
Claude 3.7 SonnetFeb 2025Hybrid reasoning; switch between fast/deep modes
Claude 4 family (Sonnet 4, Opus 4)May 2025~1M‑token context (extended reasoning); improved Computer Use and Working Notes

Part IV: Commercial Practice of Safe AI — Growth, Capital, and Partnerships

Section titled “Part IV: Commercial Practice of Safe AI — Growth, Capital, and Partnerships”

Anthropic’s valuation exceeded $61B by late 2024 and reached roughly $183B after its Series F in mid‑2025. The latest $13B round led by ICONIQ further strengthens its position across enterprise, developer, and premium consumer markets.

Revenue has grown rapidly as well: annualized run‑rate rose from about $1B in early 2025 to over $5B by August. Claude Code alone reached more than a $0.5B annualized run‑rate within three months, showing clear conversion from technology to competitive advantage.

Anthropic forged deep partnerships with Amazon and Google: it designates AWS as a primary cloud provider and offers models on Amazon Bedrock; Google has also committed billions in investment and cloud infrastructure support. Access to compute such as Trainium and TPUs enables large‑scale frontier training.

In 2025, an internal memo by CEO Dario Amodei was leaked, candidly acknowledging that to remain competitive the company had considered seeking investment from Middle Eastern sovereign capital—and recognizing the “moral risk.” He wrote: “I really wish we didn’t have to be in this position, but we are,” and, “‘No bad actor should benefit from our success’ is a hard principle on which to run a business.”

This highlights Anthropic’s core contradiction: in a capital‑intensive race, even governance with public‑benefit features cannot fully escape the pressures of “racing to the bottom.”

Table 2: Anthropic’s major financing rounds and valuation

Section titled “Table 2: Anthropic’s major financing rounds and valuation”
DateInvestorsAmountValuation
Apr 2022FTX$580MNot disclosed
Sep/Oct 2023Amazon, GoogleAmazon committed $4B (first tranche $1.25B); Google committed $2B (first tranche $500M)>$61B
Mar 2024Amazon$2.75B (completing the $4B commitment)Not disclosed
Nov 2024Amazon$4B (total investment reached $8B)Not disclosed
May 2025ICONIQ, Fidelity, Lightspeed, etc.$13B~$183B

Part V: Outlook — AGI and Societal Impact

Section titled “Part V: Outlook — AGI and Societal Impact”

Dario Amodei has expressed an aggressive timeline for AGI, even suggesting a “singularity” could arrive as early as 2026. This urgency helps explain Anthropic’s immense capital needs and the difficult trade‑offs it faces in competition.

Beyond setting a technical baseline with CAI, Anthropic actively participates in US AI policy discussions. Its collaboration with Palantir brought Claude 3/3.5 into “classified environments” for the first time—both validating capabilities and safety, and touching one of the model’s most controversial application domains.

Products like Claude Code make modern, automated software engineering a practical reality and will drive change across healthcare, education, and finance. Challenges remain: how to ensure systems apply ethical principles robustly in complex contexts; how to build regulatory and accountability frameworks; and how to rebuild public trust.

Conclusion: Anthropic’s Inevitable Choice

Section titled “Conclusion: Anthropic’s Inevitable Choice”

Anthropic began with a mission‑driven split and embedded safety into its corporate DNA through a PBC and trust‑based governance. Its rapid iteration and commercial growth suggest that a “safety commitment” can be a powerful market differentiator. Yet the leaked memo reveals persistent tension between capital and ideals.

Building powerful AI and ensuring its safety are not parallel lines but two sides of the same coin. As Anthropic moves forward along this complicated path, it will shape the technical landscape of AI and force us to confront a deeper question: in an AI‑driven world, how much principle are we willing to trade for power?

Claude Code vs Codex CLI — Which Fits Your Daily Dev?

Claude Code is more mature for engineering workflows (subagents, slash commands, hooks). Codex (GPT‑5 High) is faster, sticks closer to instructions, and gets things done with fewer words. Use both for maximum throughput.


The community has been buzzing again about Codex CLI and Claude Code. Someone built a small tool using Cloudflare Workers + Telegram: it watches Codex GitHub releases and pushes new versions to Telegram. Both agents “worked end‑to‑end”, but the experience differed in meaningful ways.

Here’s a practical, ready‑to‑apply comparison to help you choose quickly.


  • Engineering/Extensibility: Claude Code wins. Subagents, custom slash commands, and hooks are very mature.
  • Execution rhythm/plan view: Codex shows more detail in its plan panel; Claude Code defaults to “current task only”, which makes flow feel smoother.
  • Instruction adherence: Codex (GPT‑5 High) followed explicit constraints (like directory layout) more strictly; in one run it emitted multi‑file /src output, while Opus bundled code into a single worker.js.
  • Data fetching strategy: Different roads to Rome — Codex used Atom feeds; Claude Code used the GitHub API. Both got the job done.
  • Observability: Codex provides /status for token use and Ctrl+T to explore conversation history (community is adding export/persistence tooling).
  • Speed and cost perception: In a single task sample, GPT‑5 used ~90k tokens vs Opus ~50k. Because GPT‑5 is cheaper per token, total cost isn’t necessarily higher. Treat this as an anecdote, not a benchmark.
  • Docs ecosystem: Claude Code docs feel more systematic; Codex docs are improving quickly.

OpenAI is positioning Codex as a full‑field development agent: CLI, IDE extensions, cloud, and GitHub integration in one. It shares state through your ChatGPT account so a task can bounce between local and cloud. The VS Code extension is live — no API key setup, plus cloud sandbox for execution.

The release cadence is fast, so media and community reviews are everywhere.


Head‑to‑Head: Findings from a Cloudflare Worker Field Test

Section titled “Head‑to‑Head: Findings from a Cloudflare Worker Field Test”

1) Engineering Capability: Claude Code Feels Like an Orchestratable Platform

Section titled “1) Engineering Capability: Claude Code Feels Like an Orchestratable Platform”
  • Subagents: Split roles and context with separate system prompts, tools, and isolated memory. Great for “data gathering / solution review / scaffold generation” assembly lines.
  • Slash commands: Expose MCP‑discovered commands and build a team‑level action library inside your project.
  • Hooks: Force lifecycle actions (session start, before/after tool exec) to run every time. Think “lint → test → commit” guaranteed, not subject to model mood.

Bottom line: If you need scale and control, Claude Code’s orchestration is a clear advantage.

2) Execution Experience: Codex Is Snappier; Claude Code Flows Nicely

Section titled “2) Execution Experience: Codex Is Snappier; Claude Code Flows Nicely”
  • Codex is concise, sticks closely to instructions, and moves fast.
  • Claude Code’s TUI is more mature; the diff views are clear. Defaulting to the current task reduces distractions from long plans.
  • In one run, Codex had “auto run” selected but still asked for permissions fairly often; Claude Code’s interaction felt steadier.

3) Directory and Architecture Adherence: Codex “Builds to Spec”

Section titled “3) Directory and Architecture Adherence: Codex “Builds to Spec””

Given the same project template and directory constraints:

  • Codex (GPT‑5 High) produced multi‑file output under /src.
  • Claude (Opus 4.1) consolidated into a single worker.js.

If you care a lot about rigid layouts, Codex’s strictness is a plus.

4) Data Fetching Strategy: Two Valid Defaults

Section titled “4) Data Fetching Strategy: Two Valid Defaults”
  • Codex: prefer Atom feeds — conveniently structured.
  • Claude Code: call GitHub APIs — richer fields when you need them.

Both yielded what we needed for Telegram publishing; default “info density” differed slightly.

  • /status to inspect token usage; Ctrl+T for conversation history. Community PRs aim to improve export and traceability.

Choose Codex:

  • Tighter instruction following, fewer pleasantries, default behavior that just works.
  • VS Code extension + cloud sandbox makes onboarding clean and fast.

You need “Orchestration, Governance, Reuse”

Section titled “You need “Orchestration, Governance, Reuse””

Choose Claude Code:

  • Subagents for division of labor, slash commands to codify SOPs, hooks to harden workflows.
  • High reuse in teams; great for complex, multi‑person projects.

Use both:

  • Codex to spin up features and validate ideas quickly.
  • Claude Code to codify process, hook into CI, and build a team command library.

DimensionCodex (GPT‑5 High)Claude Code (Opus 4.1 exemplar)
Time‑to‑first‑shipFast, concise, gets things doneSlightly slower, steadier interaction
Instruction adherenceStrong (sticks to directory/constraints)Occasionally “helpful” consolidation
EngineeringCLI + IDE + Cloud, improving fastSubagents / Slash / Hooks are mature
Observability/status, Ctrl+T, community tooling risingMature diffs, strong task focus
Data fetchingPrefers structured feeds (Atom)Prefers rich APIs (GitHub)
Docs ecosystemImproving quicklyMore systematic today
Best use caseRapid features and experimentsComplex projects, governance, team assets

Note: this is based on public docs and a single real test. Details will change with updates.


Practical Workflow: Make It Your Daily Pipeline

Section titled “Practical Workflow: Make It Your Daily Pipeline”

Suggested pattern (copy freely):

  1. Use Codex to deliver the MVP: confirm interfaces, directories, and dependencies.
  2. Switch to Claude Code:
    • Create a “gathering subagent” to pull context (docs, API constraints, dependency risks).
    • Add slash commands for common actions (/lint, /test, /gen-release-notes).
    • Configure hooks to enforce pre‑CI actions (pre‑commit checks, tests, semantic versioning, change set generation).
  3. Return to Codex for small iterative features and regression; keep an eye on tokens with /status.

Tip: Codex’s brevity encourages quick iterations; Claude Code’s engineering primitives help turn wins into durable team assets.


This isn’t a “replacement” story. Codex is a sprinter; Claude Code is a triathlete. Use the right one for the job and you’ll find they complement each other perfectly.

Which style do you prefer? Tell us — we’ll keep this comparison updated as a living “selection guide”.

Don’t want Claude Code to feed your code to Anthropic? Use this privacy settings checklist

TL;DR: For personal accounts (Free/Pro/Max), go to claude.ai → Settings → Data & Privacy and turn off “Use my chats/coding sessions to improve the model.” For organizations/API, usage is not used for training by default; for extra assurance, use Zero Data Retention (ZDR) with an org API key for Claude Code. On your machine, disable Statsig telemetry/Sentry error reporting, don’t use /bug to upload sessions, and periodically clear local caches.


Anthropic is updating data policy for consumer products (including Claude, Pro, Max, and Claude Code when signed in with those accounts): you can choose whether chats and coding sessions are used for training; if you choose Allow, the retention period can be up to 5 years. If you choose Do not allow, the service side retains up to 30 days for operations and compliance. This choice only applies to newly created or “resumed” sessions (no retroactive scanning of dormant history). You can change it anytime in Privacy Settings.

For industry coverage and reminders about timing, see summaries from The Verge / Tom’s Guide.


Goal: prevent your chats and code from being used for training.

How to do it

  1. Open claude.ai → Settings → Data & Privacy.
  2. Turn off “Use my chats/coding sessions to improve Claude” (or similar wording).
  3. Remember: this only applies to new/resumed sessions; deleted conversations will not be used for training. You can change this later, but data already used for training cannot be undone.

Retention rules (when you disable training): backend storage for up to 30 days.


② Team / Enterprise / API (commercial products)

Section titled “② Team / Enterprise / API (commercial products)”

Default is safer: Anthropic’s commercial products (Claude for Work, Anthropic API, Claude Gov, etc.) do not use your inputs/outputs for training by default.

Even safer (recommended): sign Zero Data Retention (ZDR) and use your organization’s API key in Claude Code. ZDR currently applies only to the Anthropic API and products that use your org API key (including Claude Code).

Default retention: on the API side, 30‑day auto‑deletion (if ZDR isn’t in place and absent additional legal/risk requirements).


③ Go via cloud providers (Bedrock / Vertex) for another layer of isolation

Section titled “③ Go via cloud providers (Bedrock / Vertex) for another layer of isolation”
  • AWS Bedrock: explicitly does not use your inputs/outputs to train models; contract terms also constrain third‑party models (including Anthropic).
  • Google Vertex AI: has dedicated data governance and caching docs; enterprises can configure to meet compliance and minimize retention (read caching/governance details carefully).

This “cloud‑side isolation” suits highly regulated sectors, keeping orchestration, logs, and KMS within your cloud account under unified governance.


Local hardening you must do for Claude Code

Section titled “Local hardening you must do for Claude Code”

These are the most commonly overlooked steps in “keep it private” practice; once done, you’ll be much more at ease.

A. Disable telemetry and error reporting (keep runtime metrics local)

Section titled “A. Disable telemetry and error reporting (keep runtime metrics local)”

Officially supported environment variables (cross‑platform example):

Terminal window
# Disable Statsig telemetry (does not include code/file paths)
export DISABLE_TELEMETRY=1
# Disable Sentry error reporting
export DISABLE_ERROR_REPORTING=1
# Disable the /bug command (does not include code/file paths)
export DISABLE_BUG_COMMAND=1
# Disable all non‑essential network requests (more thorough)
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

You can also write these under the env node in ~/.claude/settings.json, and override per‑project via .claude/settings.local.json.

"env": {
"DISABLE_TELEMETRY": "1",
"DISABLE_ERROR_REPORTING": "1",
"DISABLE_BUG_COMMAND": "1",
"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
}

B. Avoid bundling full sessions for upload (don’t casually use /bug)

Section titled “B. Avoid bundling full sessions for upload (don’t casually use /bug)”
  • The official recommendation is to use /bug to submit issues; it bundles context for Anthropic to diagnose. Therefore avoid it when dealing with sensitive repos/code.
  • The community has collected an env var to disable /bug (DISABLE_BUG_COMMAND=1). This is “unofficial / may change” — for reference only.
  • Per official notes, the client can cache sessions locally for up to 30 days to aid resuming (configurable). In sensitive environments, regularly clean ~/.claude/ and set cache duration to a minimum.
  • The community has previously reported issues about .claude.json retaining conversation fragments — these are behavioral reports, not official guarantees. Add .claude/ to your security baseline and backup exclusion lists.

A “belt‑and‑suspenders” playbook (copy as‑is)

Section titled “A “belt‑and‑suspenders” playbook (copy as‑is)”

Personal accounts (must‑do)

  1. Turn off “Use to improve the model.”
  2. Periodically clean ~/.claude/; before using /bug, do redaction/sanitization.
  3. Set: DISABLE_TELEMETRY=1, DISABLE_ERROR_REPORTING=1.

Teams/enterprises (strongly recommended)

  1. Only log into Claude Code with your org API key; sign ZDR if possible.
  2. Inject the “no‑upload” env vars (Section A) centrally across servers and CI/CD.
  3. Prefer Bedrock/Vertex routes; implement cloud‑side DLP/KMS and access auditing.

  • Myth 1: “If I delete historical chats, they won’t be used for training.” → After deletion, they won’t be used for training, but whether they were trained on depends on your setting at the time; training is irreversible.

  • Myth 2: “Using Claude Code equals enterprise‑grade protection.” → It depends on the account and key you use. Claude Code signed in with a personal account is still under consumer terms.

  • Myth 3: “If I go via Bedrock/Vertex, I’m done.” → You still need to configure your own permission boundaries, key management, logging policies, and cache governance. The docs are explicit.


Data privacy has never been a simple on/off switch. It’s a set of habits: right configuration + right tools + team discipline. Work through the checklist above and your code and conversations will not be shared with Anthropic for training, while you also preserve your team’s compliance boundary.

Claude Code 1.0.9x: Permission Doctor, Direct Memory Editing, Vertex Global Endpoints, and More

A fast series of 1.0.90–1.0.97 updates lands several practical fixes and upgrades: permission rule validation, editable memory files, Vertex global endpoints, proxy compatibility, hot‑reloaded settings, and a task list. The execution loop feels much tighter for engineers.


Over the past two weeks, Claude Code shipped multiple minor versions. They look small, but each one targets high‑frequency operations: no more fragile permission rules, edit memory files directly, route Vertex via a global endpoint for higher availability, paste images easily on Windows, and see settings take effect immediately. Below is a hands‑on rundown of the most impactful changes, with copy‑ready usage.


  • 1.0.97: /doctor adds permission rule syntax validation with fix suggestions. No more losing time to a stray parenthesis or wildcard.
  • 1.0.94:
    • Vertex supports a global endpoint, improving cross‑region availability.
    • /memory can now open and edit all imported memory files directly, making team guidance easier to organize.
    • SDK adds support for custom tools as callbacks (in‑process MCP / callback hooks), making it easier to plug your own tools into the agent loop.
    • New /todos lists the current task set, helping the plan → act → verify loop feel natural.
  • 1.0.93:
    • Windows adds Alt + V to paste images from clipboard for fast inclusion of error screenshots and sketches.
    • Supports NO_PROXY to bypass specific hosts/subnets (with HTTP(S)_PROXY)), better for enterprise networks or custom proxy setups.
  • 1.0.90: Settings changes apply immediately with no restart. Note: hooks are an exception (details below).

Quick version check:

Terminal window
npm i -g @anthropic-ai/claude-code
claude update
#
claude -v # should show 1.0.9x+

01 No more guesswork: use /doctor for permission checks (1.0.97)

Section titled “01 No more guesswork: use /doctor for permission checks (1.0.97)”

Permissions are your brakes and throttle in Claude Code. Writing allow/deny used to be error‑prone; now just run:

/doctor

It will validate syntax, point out issues, and provide fix suggestions. For example, if you wrote:

{
"permissions": {
"allow": ["Bash(git commit:*)", "Edit", "ReadFile:*"],
"deny": ["Bash(rm -rf *)"]
}
}

/doctor can surface wildcard correctness, priority overlaps, and more. This is essential for a shared, unified “allowed commands” policy across teams.

Security note: the community has reported cases where deny rules didn’t take effect or command chains found bypasses. Don’t over‑grant at the start—prefer least privilege and open up gradually.


02 Team memory, edited in place: /memory (1.0.94)

Section titled “02 Team memory, edited in place: /memory (1.0.94)”

/memory now does more than show loaded CLAUDE.md files—it lets you open and edit them directly (including multi‑level imports via @path/to/file). Benefits:

  1. One change, shared impact: Put conventions in the repo so the whole team benefits.
  2. Modular structure: Use @imports to manage layers for architecture, Git rules, scaffolding commands, etc.
  3. Rapid iteration: Works great with hot‑reloaded settings.

Command:

/memory # view & edit project/personal/org CLAUDE.md

The official docs outline imports, multi‑level discovery, and org‑level paths—strongly recommended to formalize in your repos.


03 Vertex global endpoint: steadier cross‑region routing (1.0.94)

Section titled “03 Vertex global endpoint: steadier cross‑region routing (1.0.94)”

If you’re billed via Google Vertex AI, you can now use the global endpoint to route to available regions dynamically, improving availability and stability. Great for overnight long jobs or “must‑pass” CI before submission. Docs confirm Claude Code supports both global and regional endpoints for Vertex.

Tip: available models and aliases can vary by region. When switching, double‑check the endpoint ↔ model mapping.


04 Settings hot‑reload, with a hooks caveat (1.0.90)

Section titled “04 Settings hot‑reload, with a hooks caveat (1.0.90)”

From 1.0.90, most settings apply immediately—no session restart needed. This tightens the tweak → retry loop.

Exception: Hooks (pre/post execution) are not replaced immediately. The current session uses a startup snapshot; after editing hooks, open /hooks to review & apply. Don’t miss this detail.


05 Enterprise‑friendly: NO_PROXY & paste images (1.0.93)

Section titled “05 Enterprise‑friendly: NO_PROXY & paste images (1.0.93)”
  • NO_PROXY support: In complex intranet / multi‑hop proxy setups, directly connect to certain hosts or subnets and bypass the global proxy. Used with HTTP_PROXY/HTTPS_PROXY, this fits CI and bastion/egress scenarios well.
  • Windows Alt + V: Paste images directly in the terminal, ideal for embedding error screenshots/tables into context to speed up “locate → fix”.

06 SDK callbacks & custom tools: wire in your pipeline (1.0.94)

Section titled “06 SDK callbacks & custom tools: wire in your pipeline (1.0.94)”

The TypeScript SDK supports an in‑process MCP server and custom tools, so “build, lint, pre‑publish checks, canary rollback,” etc. can become tools Claude calls. Combine with callbacks/hooks to stitch together success/failure handling and audit logs.


1) Check permissions

/doctor
/permissions # view current allow/deny
/config # open settings panel

2) Layer your memory

CLAUDE.md
@docs/architecture.md
@docs/git.md
@~/.claude/personal-rules.md
/memory # edit the above files directly

3) Vertex global endpoint (illustrative)

Switch your environment to a global endpoint as per GCP docs and available models. Confirm exact endpoints and regional model support with the official documentation.

4) Enterprise proxy

Terminal window
export HTTPS_PROXY=http://user:pass@proxy.example.com:8080
export NO_PROXY=localhost,127.0.0.1,.corp.example.com

This 1.0.9x batch isn’t flashy, but each change boosts real‑world delivery: steadier permissions, easier memory management, better network availability, smoother settings, and a handy task list.

If you’re rolling out “agent‑style development” to a team, prioritize hardening permissions and memory structure first—the payoff is immediate.

Which update helps you the most? Share your practice in the comments.

Claude Code CLI Config Playbook

Want Claude Code to feel snappy, steady, and fast? Here’s a paste-and-go cheat sheet for claude config plus practical templates your team can adopt immediately.

This is a hands-on playbook: copy commands as-is, drop in configs, troubleshoot quickly. Sources are noted so you can share confidently with teammates and IT.


  • Save time: set model, permissions, and env once; fewer round trips.
  • Reduce friction: enterprise policy, project defaults, and personal prefs stop clashing.
  • Safer by default: blacklist sensitive files and dangerous commands to avoid “oops” moments.

Most of the time you’ll need these (supports -g/--global for global scope):

Terminal window
# List all settings
claude config list
# Read one key
claude config get <key>
# Set one key
claude config set <key> <value>
# Append/remove for list-like settings
claude config add <key> <value>
claude config remove <key> <value>
# Examples: set global theme & project default model
claude config set -g theme dark
claude config set model claude-sonnet-4-20250514

Official docs list these subcommands and explain the scope of -g/--global.


2) Where do settings live? Which one wins?

Section titled “2) Where do settings live? Which one wins?”

Priority from highest to lowest:

  1. Enterprise managed policy (cannot be overridden)

    • macOS: /Library/Application Support/ClaudeCode/managed-settings.json
    • Linux/WSL: /etc/claude-code/managed-settings.json
    • Windows: C:\\ProgramData\\ClaudeCode\\managed-settings.json
  2. CLI arguments (temporary for current invocation)

  3. Project local: .claude/settings.local.json (personal, git-ignored)

  4. Project shared: .claude/settings.json (team-shared)

  5. User global: ~/.claude/settings.json (personal default)

The official Settings page documents paths, precedence, and examples using consistent terminology for IT.


Terminal window
claude config set -g theme dark
claude config set -g verbose true

Both theme and verbose are built-in. verbose defaults to false.


  • CLI argument: claude --model <alias|name>
  • In-session: /model sonnet
  • Env var: export ANTHROPIC_MODEL=opus
  • Settings file: "model": "claude-sonnet-4-20250514"

Suggested combo (practical):

Terminal window
# Global default: balanced
claude config set -g model claude-sonnet-4-20250514
# For expressive tasks on demand
claude --model opus

Official docs clarify precedence and examples; include this in your team README to avoid arguments.


3) Disable nonessential traffic (privacy/intranet)

Section titled “3) Disable nonessential traffic (privacy/intranet)”
Terminal window
# Three options: settings.json, global env, or one-off env
claude config set -g env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC 1
echo 'export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1' >> ~/.zshrc
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 claude

This env var is equivalent to setting all of: DISABLE_AUTOUPDATER, DISABLE_BUG_COMMAND, DISABLE_ERROR_REPORTING, and DISABLE_TELEMETRY.


4) Don’t add “Co-authored-by Claude” to commits

Section titled “4) Don’t add “Co-authored-by Claude” to commits”
Terminal window
claude config set includeCoAuthoredBy false

includeCoAuthoredBy is officially supported and defaults to true.


5) Task-complete notifications (long tasks)

Section titled “5) Task-complete notifications (long tasks)”
Terminal window
claude config set -g preferredNotifChannel terminal_bell

See “Terminal configuration” in docs. On macOS, ensure terminal notifications are allowed.


Section titled “6) Project permissions allow/deny lists (highly recommended)”
.claude/settings.json
{
"permissions": {
"allow": [
"Bash(npm run lint)",
"Bash(npm run test:*)",
"Read(~/.zshrc)"
],
"deny": [
"Bash(curl:*)",
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)"
]
}
}

permissions.allow/ask/deny is the new mechanism replacing ignorePatterns; great for hard-blocking secrets.


7) Status Line: show model, branch, cost hints

Section titled “7) Status Line: show model, branch, cost hints”
.claude/settings.json
{ "statusLine": { "type": "command", "command": "~/.claude/statusline.sh" } }

You can also try /statusline to have Claude scaffold a starter script.


8) Enterprise-wide policy (compliance must-haves)

Section titled “8) Enterprise-wide policy (compliance must-haves)”
  • Use managed-settings.json to enforce permissions/tools.
  • Disable bypass mode so sensitive actions always require confirmation:
{
"permissions": {
"defaultMode": "acceptEdits",
"disableBypassPermissionsMode": "disable"
}
}

Enterprise policy paths and permission controls are documented in the official Settings guide.


Template A | Privacy-first on corporate networks

Section titled “Template A | Privacy-first on corporate networks”
Terminal window
# Disable nonessential traffic, error reporting, /bug, and auto-updates
claude config set -g env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC 1
claude config set -g theme dark
claude config set -g verbose true
claude config set -g model claude-sonnet-4-20250514

See the Environment Variables table for meanings and equivalents.


Template B | Frontend project (safe allowlist)

Section titled “Template B | Frontend project (safe allowlist)”
Terminal window
claude config add permissions.allow "Bash(npm run dev)"
claude config add permissions.allow "Bash(npm run test:*)"
claude config add permissions.deny "Read(./.env)"
claude config add permissions.deny "Read(./secrets/**)"

Allow test-related commands; deny reading .env and anything under secrets.


Template C | Backend project (cost control)

Section titled “Template C | Backend project (cost control)”
Terminal window
# Keep a balanced default; switch to Opus only when necessary
claude config set -g model claude-sonnet-4-20250514
# In-session: /model opus

Model precedence follows “Model configuration”: CLI > env var > settings file.


Terminal window
claude config set -g preferredNotifChannel terminal_bell

Terminal bell works well for CI or scaffolding workflows.


Template E | No automatic “Co-authored-by” in PRs

Section titled “Template E | No automatic “Co-authored-by” in PRs”
Terminal window
claude config set includeCoAuthoredBy false

Use when your team policy avoids AI co-authoring in commit messages.


  • “Why didn’t my change take effect?” Check precedence. Enterprise > CLI arg > project local > project shared > user. Higher levels can override.

  • “I want to disable all telemetry/reporting/auto-update at once.” Use CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 to cover all four switches.

  • “Where do I put the settings file?” User: ~/.claude/settings.json; Project: .claude/settings(.local).json; Enterprise: system-level managed-settings.json (see platform paths above).


Rollout in three steps:

Decide who wins (precedence & policy) → Decide what’s allowed (permissions allow/deny) → Decide how it behaves (model, output, notifications, env).

With the right setup, Claude Code becomes your team’s AI dev muscle memory: steadier, faster, safer. One set of templates, tailored per project, without friction.



  • Does your team prioritize stricter permissions or faster iteration? How will you balance both?
  • Which three rules will you enforce via enterprise policy for everyone?

Claude Code Best Practices: The Prototyping Method

First, use Claude Code to quickly “get a prototype working” to refine the requirements; then, return to engineering design and implementation to ensure quality and stability. Efficiency and quality, we want both.


The hardest part of product development isn’t writing code. It’s clearly defining “what needs to be built.”

That’s why I recommend this two-stage approach: Build a prototype in the first version, and handle the engineering seriously in the second. Claude Code is well-suited for this strategy: it works alongside you in the terminal, handling the grunt work first, allowing you to refine it later.


Stage 1: Prototype Only, Aim for “It Works”

Section titled “Stage 1: Prototype Only, Aim for “It Works””
  • Goal: Get the feature running to make the requirements tangible.
  • Ignore: Design, performance, security, code quality.
  • Method: Use throwaway code, letting the AI take the lead to quickly explore feasible paths (similar to “Spike/Throwaway Prototyping”).

Why this approach? Because many ambiguities are only exposed when the code is running. Screenshots, GIFs, and clickable prototypes are far more useful than a ten-page requirements document.

Claude Code’s advantages in this stage:

  • Directly read, modify, and run code within your local project—conversation becomes action.
  • Frequent actions can be turned into Slash Commands for one-click reuse, like “start backend + mock data + run locally.”

A word of caution: If you’re using a personal subscription, Anthropic recently introduced an opt-in mechanism for data training that includes Claude Code sessions. Check your privacy settings before prototyping company projects.


  • Trigger: Requirements are mostly finalized, and the scope is stable.
  • Deliverables: Database schema, API contracts, state management, module boundaries, testing strategy, etc.
  • Pace: Human-led, AI-assisted. You set the design anchors, and the AI builds according to the plan.

How to use Claude Code in this stage:

  • Let it scaffold the project, add boilerplate, and write tests based on your design.
  • @claude in PRs/Issues to automatically create PRs and fix minor issues (via GitHub Actions integration).
  • Write engineering conventions into a CLAUDE.md file or Slash Commands to ensure the AI follows project rules.

Security/Non-Functional Advice: Treat security, performance, and maintainability as “Technical Enablers” and progressively incorporate them into your Definition of Done (DoD) during the second stage. Conduct Spikes for validation when necessary.


  • The requirements have already been validated (e.g., redoing an old feature, a clear competitor to model after).
  • The primary risk is in the engineering implementation, not the product definition. In this case, you can proceed directly to Stage 2: Design and Implementation, with Claude Code acting as a scaffolding and execution tool.

Section titled “Field Guide: My Recommended Uses in Daily Development”

Here are practical checklists for prototyping to engineering across four common scenarios.

Example A: Growth Experiment Landing Page (Next.js)

Section titled “Example A: Growth Experiment Landing Page (Next.js)”

Prototype Version (Half a day)

  • Have Claude Code generate a minimal page, tracking events, and a form that submits to /api/echo.
  • Get it running with mock data and simple A/B test parameters.
Terminal window
# Prototype: generate page + mock API + run dev server
claude "/proto nextjs landing with /api/echo and ab flags; run dev"

Engineered Version

  • Design the routing and data models, and agree on event names for tracking.
  • Generate OpenAPI specs or protocol documents; write unit/contract tests; integrate the Claude Code Action in CI for automated checks and fixes.

Example B: Mini-Program / BLE Device Data Collection

Section titled “Example B: Mini-Program / BLE Device Data Collection”

Prototype Version

  • Prioritize getting the scan → connect → read → local cache flow working, ignoring exception handling.
  • Use Slash Commands to quickly reuse build and on-device debugging commands.

Engineered Version

  • Define the state machine (connected/disconnected/reconnecting/timeout).
  • Design the offline synchronization protocol and replay strategy; add boundary tests.
  • Create a /test-ble-reconnect command for fault injection and recovery.

Example C: Internal Approval System (Rails/React)

Section titled “Example C: Internal Approval System (Rails/React)”

Prototype Version

  • Focus only on the core workflow: submit, route, approve/reject.
  • Use an in-memory store or SQLite; don’t implement permissions yet.

Engineered Version

  • Design the RBAC and audit log table structures; write migration scripts.
  • Add rate limiting, audit export, and SLO reporting; let Claude Code automatically fix minor issues and add tests in PRs.

Example D: Data Service (FastAPI + DuckDB)

Section titled “Example D: Data Service (FastAPI + DuckDB)”

Prototype Version

  • Start with three read-only APIs for different scenarios, returning static or semi-dynamic data.
  • Ignore caching and permissions to get the frontend unblocked.

Engineered Version

  • Define the pagination/sorting/filtering protocol and error codes; add authentication.
  • Add a caching layer and rate limiting; create a /bench-api command to run load tests against a baseline.

  • Interactive terminal + command line allows for high-frequency iteration by chatting and modifying files.
  • Slash Commands solidify your “operational playbooks” for team sharing.
  • GitHub Actions bring @claude into PRs/Issues for automatic patching, PR generation, and enforcing project standards.

Together, these three features create a fast track from “idea → prototype → engineered product.”


  • Prototype drags on for too long: If requirements aren’t settled in 1-2 weeks, break it down into smaller stories; conduct a Spike summary if needed.
  • Prototype code accidentally shipped to production: Use branch isolation, directory prefixes like /proto-*, and CI checks to block it.
  • Unbounded second stage: Write an Engineering DoD (including security and performance), list non-functional items as Technical Enablers, and complete them sprint by sprint.
  • Privacy compliance: Prioritize enterprise/API channels for company projects; for personal subscriptions, always check data training opt-in settings.

Prototyping isn’t about being lazy; it’s about accelerating clarity. Engineering isn’t about being slow; it’s about reducing long-term costs.

With Claude Code, we can put these two activities in their proper place: AI leads the prototyping, humans lead the engineering. Take that hesitant requirement you have right now, and just get it running.

What do you think? Does your team get stuck more in the prototyping or engineering phase? Let’s discuss in the comments.

One‑Click Provider Switching for Claude Code & Codex with CC‑Switch

TL;DR Want to quickly switch between different providers for Claude Code and Codex — DeepSeek / Qwen Coder / GLM / Kimi K2 / packycode, etc.? CC‑Switch is an ultra‑light desktop app built on Tauri 2.0 (installer ~5 MB). It supports one‑click switching, import current config as default, switching back to official sign‑in, and automatic backups. The new v3.1.0 adds Codex provider management and one‑click switching.

Introduction: Why do you need a “one‑click provider switcher”?

Section titled “Introduction: Why do you need a “one‑click provider switcher”?”

As people who write code every day, we’re often more like dispatchers of cost and speed. Today you use Qwen Coder for speed; tomorrow you switch to DeepSeek v3.1 for complex reasoning; when compatibility issues show up, you switch back to Claude official sign‑in. If you still have to manually edit configs under ~/.claude and ~/.codex every time, it’s annoying and error‑prone.

CC‑Switch turns this into a single toggle: Click once, and the provider switches. Config copies are auto‑managed, rollback is safe, and you can return to official sign‑in at any time.


  • Truly lightweight: Built on Tauri 2.0, launches instantly. The official guidance emphasizes Tauri’s small‑footprint approach (more restrained than Electron). In v3.0.0, CC‑Switch migrated from Electron to Tauri 2.0. In author tests the bundle size dropped from ~80 MB to ~12 MB and startup sped up 10×.

  • Supports both Claude Code and Codex:

    • Claude Code primary config: ~/.claude/settings.json (or legacy claude.json) The official docs confirm ~/.claude/settings.json is the standard entry point.
    • Codex primary config: ~/.codex/auth.json (required) + ~/.codex/config.toml (may be empty) The Codex README also states ~/.codex/config.toml is the config center, supporting MCP, etc.
  • One‑click switch & automatic backups: Switching overlays the selected provider copy onto the primary config. If there’s a provider currently “in use”, CC‑Switch first writes the primary config back into that provider’s copy to facilitate rollback. Internal config v1→v2 migrations are timestamp‑backed up under ~/.cc-switch/.

  • Presets ready to use: DeepSeek v3.1, Qwen Coder, GLM, Kimi K2, packycode… just paste a key to configure with one click.

  • Switch back to official sign‑in anytime: Prefer Claude or Codex’s official sign‑in? Add the Official Sign‑In preset. After switching, restart your terminal to use /login (Claude Code) or “Sign in with ChatGPT” (Codex side).

  • Privacy‑friendly: Everything is stored locally only in ~/.cc-switch/config.json.


Supports Windows / macOS / Linux:

  • Windows: Download CC-Switch-Setup.msi or Windows-Portable.zip from Releases.
  • macOS: Download CC-Switch-macOS.zip. On first launch you may see an “unidentified developer” warning; go to System Settings → Privacy & Security → “Open Anyway”.
  • Linux: Download the .deb package.

Heads‑up: The author doesn’t have an Apple Developer account, so the first launch may be blocked; follow the steps above to allow it.


  1. Add a provider Click “Add Provider”, pick a preset or define your own, and enter the API Key. (When using an API key with Codex, OPENAI_API_KEY is common. If you’re using official account sign‑in, switch to “Codex Official Sign‑In”.)

  2. One‑click switch Check the provider you want in the list, then click the radio button. CC‑Switch overlays the copy onto the primary config:

  • Codex: overlays ~/.codex/auth.json and ~/.codex/config.toml (creates an empty config.toml if missing).
  • Claude Code: overlays ~/.claude/settings.json (or legacy claude.json).
  1. Restart or open a new terminal Open a new terminal tab or restart your terminal so the CLI picks up the latest config. Claude Code’s docs also recommend restarting for a cleaner flow when using /login.

Section titled “Three recommended usage patterns (practical)”

Set DeepSeek v3.1 as default. For frontend refactors or large‑file analysis, switch to Qwen Coder with one click; for complex reasoning, switch back to DeepSeek. No hand‑editing configs at any point.

B. “Import as default” smooth migration

Section titled “B. “Import as default” smooth migration”

Already using Codex or Claude Code? CC‑Switch automatically imports your current primary config as the default provider copy so you always have a “home base” to return to.

C. “Official sign‑in” as a safety net

Section titled “C. “Official sign‑in” as a safety net”

When debugging goes sideways or quota is tight, switch back to Claude official sign‑in or Codex Sign in with ChatGPT. Avoid detours and get things done first.


  • Codex config files The community tends to use ~/.codex/config.toml, but some mention historical versions/installs leading to different filenames or missing files (e.g., only seeing config.json). During switching, CC‑Switch creates an empty config.toml as a fallback to keep things consistent.

  • Claude Code’s official path Official docs state the user‑level config is ~/.claude/settings.json. If your older environment still uses claude.json, CC‑Switch supports that too.

  • Privacy and security CC‑Switch only modifies local files and does not send anything to a server. For team sharing, manage project‑level .claude/settings.json etc. with Git yourself (Claude Code also supports project‑level settings).


  • There are command‑line tools for provider switching, but CC‑Switch’s GUI plus “copy strategy” is more intuitive and robust.
  • If you want minimalism, visualization, and one‑click fallback to official sign‑in, it’s a great “always‑on helper.” (It complements CLI/scripts.) (Reference: There are similar community tools and posts, but CC‑Switch focuses more on “GUI + dual ecosystems”.)

Q1: If switching fails, can I roll back? Yes. The currently “in‑use” primary config is first backed up to that provider’s copy, so you can switch back to it anytime.

Q2: Codex keeps asking me to sign in or says the config is invalid. Prefer “Codex Official Sign‑In” (Sign in with ChatGPT) first, or confirm OPENAI_API_KEY and OPENAI_BASE_URL are in the correct places within auth.json/config.toml.

Q3: Why is the app so small and fast to start? Because Tauri bundles only the necessary native shell and frontend assets; the official guides emphasize the small‑bundle approach. After migrating to Tauri 2.0, the reported improvements are significant.


Turn “switching providers” into a single click, and you can focus on what really matters: writing the right code and making the right decisions. For people who collaborate across models, CC‑Switch is like a gear shifter on your desktop — handy, reliable, and fast. Give v3.1.0 a spin and let your multi‑provider workflow take off.

Three-Model Playbook for Faster Software Delivery

Gemini for discovery → ChatGPT for planning and review → Claude Code to generate and execute code → ChatGPT for post-PR review → Gemini for synthesis and knowledge capture. This “division-of-labor” chain connects think → build → review → codify in one loop.


  • Exploration → Gemini: diverge fast, surface patterns you overlooked.
  • Refinement → ChatGPT: turn insights into executable steps and check for logical gaps.
  • Integration → Claude Code: implement, polish, and ensure narrative/architecture coherence.
  • Example: for a product proposal, ask Gemini for deep needs → have ChatGPT list the functional spec → ask Claude Code to assemble a complete, shippable document or PR.

Summary of strengths: Gemini is fast with strong intuition; ChatGPT excels at reasoning; Claude is excellent at structure and clear expression. This also aligns with recent positioning: Google frames Gemini 2.5 as “thinking models” with fast/efficient Flash and stronger Pro; OpenAI highlights ChatGPT’s reasoning and planning for deep research; Anthropic pushes Claude Code as a hands-on terminal agent that can read repos, change code, and open PRs.


  • Gemini: “intuition radar” Native multimodal and thinking-model design → fast and broad coverage. Great for opening up the problem and pulling on promising threads. With 2.5 you can dial thinking budget to go broad first, then deepen.

  • ChatGPT: structured planning and deep reasoning Strong at logical decomposition, argumentation, and integrating external sources — ideal for technical plans, tradeoff analysis, and review checklists.

  • Claude Code: gets things done Built as a terminal-first coding agent: read the repo, change code, run tasks, open PRs and trigger CI. Short path from plan to PR.

Note: model strengths shift over time. Treat this split as pragmatic defaults, not hard rules. Adjust per project type.


A day-to-day development loop (with a realistic example)

Section titled “A day-to-day development loop (with a realistic example)”

Let’s walk a loop using “add a subscription management module to an existing app”.

Goal: surface true user pains behind “subscription management”, and produce journeys/boundary conditions.

Example prompt (to Gemini)

“We’re adding ‘subscription management’. From four angles — user segments (new/active/churn-risk), key motivations, cancel/retention touchpoints, and regulatory/payment compliance — map potential needs. Provide 3 high-leverage hypotheses we likely miss, each with a verifiable event and a quantifiable metric.”

Why Gemini: fast divergence/enumeration and adjustable “thinking budget” → go broad first, then narrow.


Goal: convert “hypothesis → metric → scenario” into system design and milestones.

Example prompt (to ChatGPT)

“Using the 3 high-leverage needs, output a technical solution sketch:

  1. Backend data model and event tables (keys, indexes, hot/cold tiers);
  2. Frontend key wireframes and the state machine;
  3. Risk/compliance interception points;
  4. A/B design and sample-size estimates; Conclude with milestones (two-week sprints) and a risk list (ranked by probability × impact).”

Why ChatGPT: great at structured planning and turning insights into a plan.


3) Code generation and execution (Claude Code)

Section titled “3) Code generation and execution (Claude Code)”

Goal: write code, change code, run tasks, open a PR.

How to use:

  • Install @anthropic-ai/claude-code, enter your repo, and chat; Claude will index the repo and resolve dependencies.
  • In PRs/Issues, mention @claude to generate or modify code and create a PR.

Example command (conceptual)

Terminal window
# At repo root
claude "Create backend event tables for subscription management, add migrations, and integrate tests; if a Stripe Webhook exists, mount a handler. Then open a feature branch and submit a PR."

The value is end-to-end: read code, modify code, run scripts, and drive the Git flow in one loop.


Goal: probe for issues and fix them. Give ChatGPT the Claude-generated PR and ask for a checklist across complexity, testability, rollback strategy, and failure paths, plus concrete Diff suggestions.

ChatGPT’s recent deep-research/long-chain reasoning is well-suited to serve as a contrarian reviewer.


5) Synthesis and knowledge capture (Gemini)

Section titled “5) Synthesis and knowledge capture (Gemini)”

Goal: capture the iteration as postmortem cards and knowledge-base entries. Have Gemini read the PR, issues, CI logs, and alerts, then output:

  • A one-page postmortem (goals, actions, results, learnings, debt);
  • Three stakeholder summaries (ops/support/legal) with different lenses;
  • A next-iteration discovery list and a draft of automated regression cases.

Gemini shines on multi-role summaries and cross-scenario synthesis with speed and breadth.


  1. Document the split in the repo In CONTRIBUTING.md, codify the default loop: discover → plan → implement → review → synthesize. Reduce context-switching.
  2. Wire actions into CI/CD Enable Claude Code GitHub Actions to trigger PR generation/modification from comments.
  3. Mobile or Android projects Use Gemini Code Assist inside the IDE for error dissection and fix suggestions.
  4. Mind safety and compliance Follow Google’s GenAI safety guidance: data minimization, explainability, and robust rollback.

Copyable loop checklist (paste into your team wiki)

Section titled “Copyable loop checklist (paste into your team wiki)”
  • Gemini — discovery: segments, journeys, edge cases, key metrics.
  • ChatGPT — planning: architecture/data/state machine, milestones, experiments.
  • Claude Code — implementation: read repo, change code, run tests, branch, PR.
  • ChatGPT — review: complexity, observability, rollback, failure paths.
  • Gemini — synthesis: one-pager, stakeholder summaries, next discovery + regression.

Treat models like people with roles, not a generic toolbox. Send the fast-intuitive one to explore, the deliberative one to plan, the hands-on one to ship. When each step has an “owner”, your delivery rhythm flows.

Would this split work for you? How would you tweak it? Drop thoughts in the comments.

Zed Adds ACP for Claude Code and Gemini: Many AI Teammates, One Editor

Zed turns “agents” into a standard interface (ACP) and invites your command‑line agents into the editor. Gemini CLI is first‑class; Claude Code can run in Zed via a community ACP bridge. Multi‑agent coexistence is the new normal.


  • ACP is “LSP for AI coding agents.” Zed open‑sourced the spec (Apache). Any agent that implements ACP can run in Zed.
  • Gemini CLI integration: from Zed 0.201.5, create Gemini threads in the Agent panel; Zed can auto‑install; requires Gemini CLI ≥ 0.2.0.
  • Claude Code works via community bridge acp-claude-code: add one config snippet; supports auto‑accepting file edits permission mode.
  • Feature gaps to note: Gemini CLI currently lacks message history editing/restore, checkpoints, and SSH project usage — on the roadmap.
  • Data stays local: third‑party agent traffic does not tunnel through Zed servers. Multi‑buffer visual diffs and live previews are excellent.

  1. Editor–Agent decoupling Like LSP for languages, ACP lets you choose which agent plays. In the same project, switch agents for different tasks anytime.

  2. Real CLI power, visualized in the editor Zed spawns real Gemini CLI subprocesses and speaks JSON‑RPC. You get all CLI capabilities plus live change visualization and multi‑buffer reviews.

  3. Open spec and growing ecosystem ACP is open (Apache). The Neovim community is also adding ACP‑compatible agents. This isn’t single‑editor locked.


Prepare Zed: Stable 0.201.5+ supports external agents. Open the Agent panel (cmd‑?), click the + button to start a Gemini thread. Optional keybinding:

[
{ "bindings": { "cmd-alt-g": ["agent::NewExternalAgentThread", { "agent": "gemini" }] } }
]

Prepare Gemini CLI:

  • If not installed, Zed will install it; otherwise it uses your PATH.
  • Requires ≥ 0.2.0. Upgrade:
Terminal window
npm install -g @google/gemini-cli@latest
  • Sign‑in options: Log in with Google / GEMINI_API_KEY / Vertex AI.

Usage tips:

  • Supports @file, @thread, @symbol, and web grabbing.
  • Not yet supported: message history edit/restore, checkpoints, SSH projects inside Zed.

One‑Step Claude Code in Zed (Community Bridge)

Section titled “One‑Step Claude Code in Zed (Community Bridge)”

You can also use Claude Code in Zed via the community ACP bridge acp-claude-code. Add this to your Zed settings (auto‑accept edits supported):

{
"agent_servers": {
"claude-code": {
"command": "npx",
"args": ["acp-claude-code"],
"env": {
"ACP_PERMISSION_MODE": "acceptEdits"
}
}
}
}

The bridge implements an ACP agent that wraps the Claude Code SDK: session continuity, streaming output, tool calls, permission modes, and more. The Zed team notes native support is in progress; use the bridge for now.

Note: acceptEdits only auto‑accepts file edits. bypassPermissions skips all prompts — not recommended unless running batch jobs in a clean sandbox.

Install Claude Code if needed:

Terminal window
npm install -g @anthropic-ai/claude-code

  • Large‑repo refactors and batch fixes: multi‑buffer review + live diffs = changes at a glance.
  • Multi‑agent “PK”: Gemini drafts refactor plans; Claude Code adds tests and commit messages — all inside one editor.
  • Security/compliance teams: external agent traffic doesn’t traverse Zed servers.

  • Run dev: open acp logs from the command palette to inspect Zed↔Agent messages. Super clear for troubleshooting.
  • Need a quick thread shortcut? Action name: agent::NewExternalAgentThread.

  • Today: Gemini CLI integration shipped.
  • Happening now: Claude Code via community ACP bridge is active and improving.
  • Likely next: ACP is open; more agents (e.g., Codex CLI, Cursor CLI) can plug in. Zed’s post encourages third‑party agents and other editors to join.

  1. Gemini path
  • Update Zed to ≥ 0.201.5.
  • Open Agent panel → new Gemini thread. If needed: npm i -g @google/gemini-cli@latest.
  1. Claude Code path (bridge)
  • Install Claude Code: npm i -g @anthropic-ai/claude-code.
  • Add the agent_servers snippet above; recommend ACP_PERMISSION_MODE=acceptEdits.
  1. Debug
  • Use dev: open acp logs to diagnose permission/session issues.

  • In your repo, which tasks suit Gemini better? Which ones suit Claude Code?
  • Should the team adopt a permission policy (e.g., auto‑accept edits only, never auto‑run commands)?
  • Worth hosting an internal “multi‑agent PK” learning session?

Plug Claude Code into China LLMs: DeepSeek / GLM-4.5 / Kimi K2

Point Claude Code at Anthropic-compatible China model APIs and it just works: write code, run commands, even open PRs.

— Don’t overthink it. Follow this step-by-step and copy as you go.


Everyone is trying Claude Code lately. The problem: your company network/budget doesn’t allow direct overseas access. Now what?

Good news: multiple top China providers offer Anthropic-compatible endpoints. Change Claude Code’s Base URL + Key and you’re in. This guide walks you through DeepSeek, Zhipu GLM-4.5, and Kimi K2, plus a quick “gotchas” checklist.


Terminal window
# Requires Node.js 18+
npm install -g @anthropic-ai/claude-code

After installation, run claude in your terminal for the interactive UI. Node 18+ is supported; use /config inside Claude Code to tweak settings.

  • DeepSeek: create a key in the platform’s API Keys page.
  • Zhipu Z.AI (GLM-4.5): generate a key in the console.
  • Kimi K2 (Moonshot): generate a key in the console.

3) Set environment variables (temporary test)

Section titled “3) Set environment variables (temporary test)”

Export these in your current terminal session. They will reset on new sessions. For persistent setup, see “Long-term config” below.


Option A: DeepSeek (official Anthropic-compatible endpoint)

Section titled “Option A: DeepSeek (official Anthropic-compatible endpoint)”

Temporary setup:

Terminal window
export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_DeepSeek_API_Key"
export ANTHROPIC_MODEL="deepseek-chat"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek-chat"
export API_TIMEOUT_MS=600000

Then in your project directory:

Terminal window
claude

DeepSeek’s docs provide the Anthropic-compatible path, recommended model names, and a note to raise the timeout for long outputs.

Long-term config (zsh example):

Terminal window
cat >> ~/.zshrc <<'EOF'
export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_DeepSeek_API_Key"
export ANTHROPIC_MODEL="deepseek-chat"
export ANTHROPIC_SMALL_FAST_MODEL="deepseek-chat"
export API_TIMEOUT_MS=600000
EOF
source ~/.zshrc

Verify: once started, type /status to see the current model; echo $ANTHROPIC_BASE_URL to double-check.


Option B: Zhipu GLM-4.5 (Z.AI official guides for Claude Code)

Section titled “Option B: Zhipu GLM-4.5 (Z.AI official guides for Claude Code)”

Temporary setup:

Terminal window
export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_ZAI_API_Key"
# Optional: set default model
export ANTHROPIC_MODEL="glm-4.5"

Z.AI’s docs publish the Anthropic-compatible endpoint and show how to switch glm-4.5 vs glm-4.5-air via ~/.claude/settings.json.

Switch model via settings.json (optional):

{
"env": {
"ANTHROPIC_MODEL": "glm-4.5-air"
}
}

Open a new terminal and run claude, then /status in the UI.


Option C: Kimi K2 (Moonshot’s Anthropic compatibility)

Section titled “Option C: Kimi K2 (Moonshot’s Anthropic compatibility)”

Temporary setup (global domain is more reliable):

Terminal window
export ANTHROPIC_BASE_URL="https://api.moonshot.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="your_Moonshot_API_Key"
# Some deployments map temperature to ~0.6; defaults are fine

Moonshot emphasize compatibility with both OpenAI and Anthropic for K2 in the repo and blog. Community guides commonly use https://api.moonshot.ai/anthropic as the Base URL. Note: some posts show .cn which can fail. Prefer .ai or check the console docs.


Inside claude, do these three quick checks:

  1. Check model: /status or ask “What is your current model ID?”
  2. Run a command: /bash echo "hello cc" to see if the permission prompt works.
  3. Edit a file: ask it to create README_CC.md in a sample repo to confirm read/write.

These are all part of the recommended Claude Code workflow and setup.


Q1: 401 Unauthorized?

Claude Code supports two auth positions:

  • ANTHROPIC_API_KEY (sent as X-Api-Key)
  • ANTHROPIC_AUTH_TOKEN (sent as Authorization: Bearer)

China-compatible endpoints generally prefer ANTHROPIC_AUTH_TOKEN together with a custom Base URL.

Q2: Can’t connect / 404?

  • Ensure the Base URL includes /anthropic (e.g., DeepSeek and Moonshot compatibility endpoints).
  • Use .ai for Kimi; some .cn endpoints may not work.

Q3: Built-in WebSearch tool doesn’t respond?

When not using Anthropic’s official API, the built-in WebSearch tool is not available. Use an external MCP search tool (Tavily/Brave/DuckDuckGo, etc.).

Q4: Long outputs timing out?

DeepSeek recommends API_TIMEOUT_MS=600000 (10 minutes).

Q5: Multimodal / image messages?

Compatibility endpoints may not fully support every Anthropic field (e.g., images/doc content). Check the vendor docs.


  • Protect repo secrets: add .env and secrets/** to permissions.deny in ~/.claude/settings.json.
  • Sanitize sensitive code: mirror the repo or remove keys before sharing with AI.
  • Permission mode: keep prompts enabled. Only use --dangerously-skip-permissions when you completely trust the environment.

ProviderBase URLRequired Env VarRecommended Model
DeepSeekhttps://api.deepseek.com/anthropicANTHROPIC_AUTH_TOKENdeepseek-chat
Zhipu Z.AIhttps://api.z.ai/api/anthropicANTHROPIC_AUTH_TOKENglm-4.5 / glm-4.5-air
Kimi K2https://api.moonshot.ai/anthropicANTHROPIC_AUTH_TOKEN(use platform’s default routing)

All entries are from official vendor documentation or commonly used, tested settings.


Don’t want to export every time? Put env vars in ~/.claude/settings.json:

{
"env": {
"ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
"ANTHROPIC_AUTH_TOKEN": "xxxxx",
"ANTHROPIC_MODEL": "deepseek-chat",
"API_TIMEOUT_MS": "600000"
}
}

settings.json is the officially recommended layered config (global/project), covering env, permissions, hooks, and more.


With domestic models connected, Claude Code remains the same “turn ideas into code” engine. Which one feels best? DeepSeek is fast, GLM-4.5 thinks steadily, and K2 is great value. Try them side by side.

Once you have one path working, your team can pilot low-cost AI code collaboration and turn efficiency into real outcomes.

Which combo works best for you? Any pitfalls you’ve hit? Share your practices in the comments.

Claude Code CLI Playbook: REPL, Pipes, Sessions & Permissions

GUIs are great, but the command line is faster, steadier, and composable. Claude Code CLI is that trusty knife: open a REPL, one-shot via pipes, resume past sessions, and fine-tune permissions — all with a single command.

This guide covers 90% of daily CLI usage with minimal memorization. If you can copy it, don’t type it. If you can automate it, don’t do it by hand.


  • REPL: claude to chat; claude "…" to start with a question.
  • Print/Pipe: -p is non-interactive one-shot; pair with --output-format json/stream-json for orchestration.
  • Sessions: -c resumes last; -r picks from history; --session-id pins a long-running thread.
  • Permissions: --permission-mode for granularity; --allowedTools/--disallowedTools for allow/deny lists.
  • Dangerous skip: --dangerously-skip-permissions only in offline/sandbox environments.

#1 REPL Mode: a “conversational IDE” in your terminal

Section titled “#1 REPL Mode: a “conversational IDE” in your terminal”

Most common launches:

Terminal window
claude
claude "explain this project like I'm new here"

Handy tips:

Terminal window
claude --ide
claude --append-system-prompt "You are a careful code reviewer."

Mindset: REPL is perfect for exploratory work, incremental refactors, and step-by-step walkthroughs. Switch models on the fly with --model sonnet (or a full model ID).


#2 Print / Pipe Mode: scriptable, one-and-done

Section titled “#2 Print / Pipe Mode: scriptable, one-and-done”

The core is -p: read from stdin → produce one response → exit. Ideal for scripts, CI, and batch jobs.

Terminal window
claude -p "explain this function"
cat server.log | claude -p "summarize error patterns"
git diff | claude -p "write a clear PR description"

Orchestration-friendly formats:

Terminal window
claude -p "summarize as JSON" --output-format json
cat api.md | claude -p --input-format stream-json --output-format stream-json

Pipeline example (with jq):

Terminal window
git diff | claude -p "summarize as JSON with keys: title, bullets" --output-format json \
| jq -r '"# \(.title)\n- " + (.bullets | join("\n- "))'

#3 Session Management: resume, browse, and pin IDs

Section titled “#3 Session Management: resume, browse, and pin IDs”

Four essentials:

Terminal window
claude -c
claude -c -p "Check for type errors"
claude -r
claude -r "550e8400-e29b-41d4-a716-446655440000" --no-interactive "fix all linting issues"

Pin a session ID for “long-term project concierge”:

Terminal window
export CC_SID="12345678-1234-1234-1234-123456789abc"
claude --session-id $CC_SID "Keep maintaining the release plan"

Tip: give each long-running task its own --session-id to keep context stable and history traceable.


#4 Permission Modes: speed with boundaries

Section titled “#4 Permission Modes: speed with boundaries”

Four modes, clearly defined:

Terminal window
claude --permission-mode default
claude --permission-mode acceptEdits
claude --permission-mode plan
claude --permission-mode bypassPermissions

“Permission prompt proxy” for non-interactive environments (e.g., CI): let an MCP tool handle prompts on your behalf.

Terminal window
claude -p --permission-prompt-tool mcp_auth_tool "run code review"

#5 Dangerous Skip: only in offline/sandbox

Section titled “#5 Dangerous Skip: only in offline/sandbox”
Terminal window
claude --dangerously-skip-permissions

Safe to use when:

  • Local sandbox with no network.
  • Demo/training setups with read-only FS or snapshots you can roll back.
  • Disposable environments you’ll destroy after the run.

Avoid when:

  • Production, repos with secrets, CI that writes to real resources.
  • Any scenario where you don’t want auto shell execution or file writes.

Rule of thumb: if you can avoid it, do. If you must, isolate first.


Precisely control which tools can be used; child-command wildcards are supported.

Terminal window
claude --allowedTools "Bash(git:*), Edit"
claude --disallowedTools "Bash(rm:*)"

Recommended for CI: allow only what you need for edits; block dangerous commands.

Terminal window
claude -p \
--permission-mode acceptEdits \
--allowedTools "Edit" \
--disallowedTools "Bash(rm:*), Bash(curl:*), Bash(wget:*)"

#7 I/O Formats: seamless upstream/downstream

Section titled “#7 I/O Formats: seamless upstream/downstream”
Terminal window
claude -p "explain"
claude -p --input-format stream-json --output-format stream-json --replay-user-messages

What does --replay-user-messages do? In streamed JSON pipelines, it replays stdin “user” messages to stdout so middleware can align event flows upstream and downstream.


#8 Advanced Trio: model, dirs, and settings

Section titled “#8 Advanced Trio: model, dirs, and settings”
Terminal window
claude --model sonnet --fallback-model opus -p "explain the migration plan"
claude --add-dir ../apps ../lib --cwd ./apps/web
claude --settings ./cc.settings.json

Example cc.settings.json:

{
"verbose": true,
"maxTurns": 8,
"appendSystemPrompt": "Prefer clear diffs and small PRs."
}

Terminal window
claude
claude "help write a release note"
claude -p "explain this function" --output-format text
cat logs.txt | claude -p "find top 5 recurring errors"
git diff | claude -p "summarize as JSON" --output-format json
claude -c
claude -r "550e8400-e29b-41d4-a716-446655440000" --no-interactive "finish the refactor"
claude --session-id 12345678-1234-1234-1234-123456789abc
claude --permission-mode plan
claude --allowedTools "Edit"
claude --disallowedTools "Bash(rm:*)"
claude --dangerously-skip-permissions

The CLI shines for two reasons: speed and composability. Use REPL for exploration; use -p for automation and pipelines. With traceable sessions, controllable permissions, and orchestratable output formats, Claude Code fits naturally into your engineering rhythm.

Type 10× fewer commands, deliver 10× more results.

Which combo works best for you? Share your “command flows” in the comments — I’ll turn a few into posters and send you a Vibe Coding quick-start pack.


  • Do you use REPL or -p more often — and why?
  • When do you enable acceptEdits?
  • Do you have a one-liner pipeline you swear by? Share it so we can learn from it.

Mastering Claude Code Sessions: Continue, Resume, Automate

Teach Claude Code to “pick up the thread” with the quartet of --continue / --resume / --session-id / non-interactive mode, so you can keep previous context intact, coordinate multiple tasks, and automate reliably.


Writing code is like training — the worst enemy is interruption. You discussed a refactor plan with Claude Code yesterday, and today you forget where you left off? Running multiple threads gets mixed up? Your script loses context after two turns?

This article explains how Claude Code sessions work and how to resume instantly, recover specific threads, run many in parallel, and keep context in scripts — so your Vibe Coding rhythm never drops.


  • Continue yesterday’s thread: jump right back into the last conversation.
  • Work on two tracks: bugfix on one branch, new feature on another, without interference.
  • Script automation: multi-turn interaction in CI/scripts without losing context.
  • Privacy and cost: local retention and awareness of summarization cost.

1) Fastest: continue the most recent conversation (--continue / -c)

Section titled “1) Fastest: continue the most recent conversation (--continue / -c)”
  • Command:

    Terminal window
    claude --continue
    # or
    claude -c
  • Mindset: zero choices — immediately resume the most recent session; no need to reconfigure the environment.

  • Tip: resume the latest session inside a script and print the result:

    Terminal window
    claude --continue --print "Continue the refactor and add unit tests"

    (--print is equivalent to -p, i.e., non-interactive output.)


2) More precise: resume a specific session (--resume / -r)

Section titled “2) More precise: resume a specific session (--resume / -r)”
  • Interactive “session picker”:

    Terminal window
    claude --resume

    This shows a list of past sessions (start time, first prompt or summary, message count). Use arrow keys to choose. Great when you switch tracks several times a day.

  • Resume directly by session ID:

    Terminal window
    claude --resume 550e8400-e29b-41d4-a716-446655440000 "Finish the API abstraction layer"
    # or
    claude -r 550e8400-e29b-41d4-a716-446655440000 "Keep writing integration tests"

    Perfect for scripts/automation where you need exact control.


3) Script-friendly: capture session_id + non-interactive multi-turn

Section titled “3) Script-friendly: capture session_id + non-interactive multi-turn”

Idea: start once to capture a session_id, then chain every subsequent step with --resume $sid.

Terminal window
# Step 1: start a session and grab session_id (present in JSON output)
sid=$(claude -p "Start a refactor session: list the risk points" --output-format json | jq -r '.session_id')
# Step 2: chain non-interactive turns
claude -p --resume "$sid" "According to the plan, refactor utils/date.ts first"
claude -p --resume "$sid" "Add ts-jest config and unit test examples"
  • Key point: --output-format json includes a session_id field; you can also use --no-interactive with --resume for strictly non-interactive runs.

Caution: some users report that repeatedly using --continue in non-interactive mode may create a new session, which looks like it resumed but actually changed IDs. For automation, prefer fixed session_id + --resume.


Inside the interactive REPL, type:

/resume

You’ll get a list of sessions to restore. This is the same source as --resume/--continue, triggering the same SessionStart/Resume logic (as noted in Hooks docs).

Handy REPL keys:

  • Esc Esc: edit the previous message
  • ↑ / ↓: browse history in the current session

Great for quickly tweaking your last prompt.


Parallel, Not Cross-Talk: isolate sessions with Git worktrees

Section titled “Parallel, Not Cross-Talk: isolate sessions with Git worktrees”

Want to push “bugfix” and “new feature” at the same time? Use git worktree to create two working directories. Launch Claude Code separately in each directory so context stays naturally isolated:

Terminal window
git worktree add ../proj-feature-a -b feature-a
git worktree add ../proj-bugfix bugfix-123
cd ../proj-feature-a && claude
cd ../proj-bugfix && claude

This workflow is strongly recommended: sessions and file state won’t affect each other.


Privacy & Cost: session retention and background summaries

Section titled “Privacy & Cost: session retention and background summaries”
  • Local retention: the client stores sessions locally (configurable; common defaults keep ~30 days) for --resume. Enterprises can set zero data retention.
  • Background summarization: to power --resume lists and previews, Claude Code performs background session summarization, incurring a small token cost.

Bash multi-turn template:

Terminal window
# Start a session and save its ID
sid=$(claude -p "Prepare release: generate change list" --output-format json | jq -r '.session_id')
# Chain subsequent steps to the same session
claude -p --resume "$sid" "Generate release notes in Chinese and English"
claude -p --resume "$sid" "Check CI failures and provide fix commands"
claude -p --resume "$sid" "Output a final checklist.md"

(--print/-p is non-interactive; you can also force non-interactive with --no-interactive.)

Quick interactive entry points:

Terminal window
# Most recent
claude --continue
# Pick from history
claude --resume
# In REPL
/resume

Advanced: hook sessions into team workflows (optional)

Section titled “Advanced: hook sessions into team workflows (optional)”

If you’ve configured Hooks such as SessionStart/SessionEnd, resuming a session also triggers them. You can automatically load the latest issues, change summaries, or safety checks at resume time.


Session management isn’t a nice-to-have — it’s the foundation for keeping momentum. Use --continue for quick, ad-hoc resumption; use --resume + session_id for long-running, replayable work; use worktree for physical isolation; and bring it all into scripts. Your Vibe Coding will evolve from sketchy inspiration to a reproducible creative pipeline.

Which session pattern do you need most right now? Share in the comments.

Claude Code Playbook 1.10: Outsource Permissions to Your MCP Tool with claude code --permission-prompt-tool


Keep getting interrupted by permission prompts? Want Claude Code to run in CI/CD, nightly jobs, or remote containers without flipping “allow everything”?

The answer is this switch: --permission-prompt-tool. It delegates the decision of “allow this tool call?” to a specific MCP tool you choose. It supports conditional approval, audit trails, and can run in non-interactive CLI and headless setups. The CLI docs explicitly state its purpose: in non-interactive mode, your MCP tool handles permission prompts.

Permission order is also clear: first check settings.json / --allowedTools / --disallowedTools. If a rule applies, it’s allowed or denied immediately. Otherwise Claude calls your --permission-prompt-tool. The official SDK docs describe the full flow and the JSON response format.


  • What it is: a bridge that delegates “allow or deny tool use” to an MCP tool. Great for automation, headless, and compliance.
  • How decisions are made: static rules first (settings/allowed/disallowed). If no match, Claude calls your permission agent, which returns JSON: allow or deny.
  • Best use cases: CI/CD, batch refactors, remote containers/servers, IDE/plugins, enterprise audit/compliance.
  • Why sec teams like it: auditable, recordable, granular, aligned with IAM and least privilege. Even better with an MCP allowlist.

It forwards the question “should we allow this tool call?” to your MCP tool. That MCP tool can enforce approvals, allow/deny lists, time-of-day policies, Slack approvals, risk scoring—your rules, your control. This works in both CLI and headless modes.

Claude Code applies a three-layer permission check:

Check predefined permission rules first:

  • settings.json
  • CLI --allowedTools
  • CLI --disallowedTools

If layer 1 yields a clear answer → allow or deny directly. If there’s no rule → go to layer 3.

Ask the MCP tool you specify to decide: --permission-prompt-tool your_custom_tool

Suppose Claude wants to use Write to modify files.

Case 1: statically allowed

settings.json
{
"allowedTools": ["Write", "Read"]
}

Result: allowed immediately; MCP tool is not called.

Case 2: statically denied

settings.json
{
"disallowedTools": ["Write"]
}

Result: denied immediately; MCP tool is not called.

Case 3: no static rule

settings.json
{
"allowedTools": ["Read"]
// no rule about Write
}

Result: call the MCP tool specified by --permission-prompt-tool.

Expressed in code:

def check_permission(tool_name):
# Layer 1: static config
if tool_name in settings.allowedTools:
return True # allow immediately
if tool_name in settings.disallowedTools:
return False # deny immediately
# Layer 2: no rule, ask MCP tool
if permission_prompt_tool:
return permission_prompt_tool.ask_permission(tool_name)
# Default (usually: ask the user)
return prompt_user(tool_name)

Enterprise example: most tools pre-configured; exceptional calls require dynamic approval.

Terminal window
claude code --allowedTools "Read,Grep,LS" \
--disallowedTools "Bash:rm,Bash:sudo" \
--permission-prompt-tool enterprise_approver \
"analyze codebase"

Flow:

    1. Claude uses Read → allowed by static config ✅
    1. Claude wants Bash:rm → denied by static config ❌
    1. Claude wants Write → no rule; ask enterprise_approver ❓

Benefits:

  • Performance: fast decisions for common tools via static rules
  • Flexibility: edge cases handled dynamically
  • Security: default to deny; explicit authorization required

  • Goal: run code edits, test fixes, and reporting in pipelines without permission pop-ups.
  • How:
Terminal window
claude -p "fix flaky tests and commit" \
--allowedTools "Read,Grep" \
--disallowedTools "Bash(rm*),Write" \
--mcp-config ci-tools.json \
--permission-prompt-tool mcp__sec__approval_prompt \
--output-format json
  • Effect: anything not covered by static rules gets routed to mcp__sec__approval_prompt for remote approval. Pipelines keep flowing.
  • Goal: nightly bulk edits, formatting, and migration PRs.
  • How: mark “critical-path edits” as require-approval, allow the rest statically. Log every change for audit.
  • Basis: define granular IAM rules by tool/path, e.g., Edit(docs/**), Bash(npm run test:*).
  • Goal: safely allow necessary actions where there’s no UI (Docker/SSH, headless).
  • How: enable the permission prompt tool in headless (non-interactive) mode:
Terminal window
claude -p "build and publish image" \
--permission-prompt-tool mcp__guard__prompt \
--mcp-config /etc/mcp/servers.json
  • Note: headless docs indicate --permission-prompt-tool applies in --print non-interactive flows.

4) “Delegated approver” inside IDE/plugins

Section titled “4) “Delegated approver” inside IDE/plugins”
  • Goal: let a GUI agent or Slack bot handle approvals on behalf of the IDE user.
  • How: MCP tool shows a GUI or posts a Slack card; approver clicks and returns allow/deny.
  • Security: MCP servers must be trusted and auditable per org policy.

How it works (official mechanism translated)

Section titled “How it works (official mechanism translated)”
  • Priority: check settings.json and CLI --allowedTools / --disallowedTools first. If they decide, act; otherwise call your MCP tool.

  • Response format (must be a JSON string):

    • Allow:

      {"behavior":"allow","updatedInput":{...}}
    • Deny:

      {"behavior":"deny","message":"..."}
    • updatedInput lets your agent return human-amended input back to the model (e.g., an edited diff).


const server = new McpServer({ name:"sec-approval", version:"0.0.1" });
server.tool(
"approval_prompt",
"Return allow/deny for tool use",
{ tool_name: z.string(), input: z.object({}).passthrough() },
async ({ tool_name, input }) => {
const allow = await riskCheck(tool_name, input); // your risk logic
const payload = allow
? { behavior: "allow", updatedInput: input }
: { behavior: "deny", message: "Policy denied by SEC team" };
return { content: [{ type: "text", text: JSON.stringify(payload) }] };
}
);

Start it like this:

Terminal window
claude -p "migrate configs safely" \
--allowedTools "Read,Grep" \
--disallowedTools "Bash(rm*),Write" \
--mcp-config security-tools.json \
--permission-prompt-tool mcp__sec-approval__approval_prompt

Headless and CLI parameter mappings are available in the official docs.

async def approval_prompt(tool_name: str, input: dict):
ok = policy_match(tool_name, input)
if ok:
return json.dumps({"behavior":"allow","updatedInput":input})
return json.dumps({"behavior":"deny","message":f"Denied {tool_name}"})

The official SDK also documents Python/TS structures and fields.


  • --dangerously-skip-permissions: bluntly skips all prompts. The docs warn to use sparingly.
  • --permission-prompt-tool: controlled, auditable, and extensible. Aligns with enterprise security/compliance. You can authorize by directory/command, e.g., Bash(npm run test:*), Edit(docs/**).

Best-practice checklist (enterprise-ready)

Section titled “Best-practice checklist (enterprise-ready)”
  1. Three layers: static first (settings/allowed/disallowed) → MCP agent as fallback → default deny.
  2. MCP allowlist: connect only to trusted MCP servers, managed via repo config.
  3. Granular matching: use Bash(…), Edit(…), mcp__server, mcp__server__tool for precise authorization; wildcards are not supported by MCP.
  4. Audit and replay: log decisions in the permission agent; pair with --output-format json to persist runs.
  5. Risk isolation: run inside containers/DevContainers to limit blast radius.

  • Wrong tool naming: mcp__<server>__<tool> denotes a single tool; mcp__<server> allows all tools from that server. No wildcards.
  • Expecting prompts in interactive mode: this switch primarily targets --print non-interactive flows.
  • Treating it as a silver bullet: keep base permissions in settings/allowed/disallowed to reduce calls and network exposure.
  • Ignoring MCP security: evaluate third-party servers carefully and apply least privilege.

Allow common read-only tools + deny risky commands + MCP fallback:

Terminal window
claude -p "refactor and open PR" \
--allowedTools "Read,Grep,LS" \
--disallowedTools "Bash(rm*),Write" \
--mcp-config team-mcp.json \
--permission-prompt-tool mcp__approver__prompt \
--output-format json

Authorize by command granularity:

Terminal window
claude -p "run tests" \
--allowedTools "Bash(npm run test:*),Read" \
--permission-prompt-tool mcp__approver__prompt

All parameter semantics, permission modes, and match patterns are covered in the official CLI / IAM / headless docs.


--permission-prompt-tool is not just a toggle—it’s an enterprise-grade “permission gateway” interface. You can move risk evaluation, human approvals, and audit trails into a single MCP tool. Automation without recklessness: keep both efficiency and security strong.

Does this permission design satisfy your compliance needs? Tell us how you’d wire Slack/Teams/ticketing to “click-to-approve”.

Who Should Use Claude Code? Perspectives by Role — Vibe Coding Experiences and Use‑Case Analysis

In recent years, AI coding assistants have proliferated. Among them, Anthropic’s Claude Code (CC) has drawn attention by positioning itself as an “intelligent coding tool in your terminal.”

“Vibe Coding” refers to using these tools to rapidly turn ideas in your head into code — a fast‑iterating, intuition‑driven development flow.

This article distills feedback from different types of users, explains the reasons behind the patterns, and summarizes where Claude Code shines in Vibe Coding. We also compare CC to adjacent tools (Cursor, GitHub Copilot, OpenAI Codex CLI, Cursor CLI, Google Gemini CLI, etc.) to highlight strengths, weaknesses, and fit.


How Different People Experience Claude Code

Section titled “How Different People Experience Claude Code”

Users with different backgrounds report notably different experiences when using CC for Vibe Coding:

  • Claude Code isn’t a one‑click “build an app” magic wand. It expects clear natural‑language tasking so it can “plan, write code, and ensure it works.”
  • People with no coding literacy struggle to phrase effective instructions or judge correctness, so CC is “hard to drive.”
  • CC primarily runs in the terminal, assuming some dev environment and command‑line experience — a non‑trivial barrier for beginners.

2) Senior architects: cautiously skeptical

Section titled “2) Senior architects: cautiously skeptical”
  • Many view CC’s value as “limited” — hand‑writing the code feels safer and more reliable.
  • CC can help “debug and fix issues,” scanning a codebase for bugs and proposing patches, but results still require human review.
  • The permissioned workflow asks for user approvals step by step (you can enable Yolo mode to auto‑approve), which can feel inefficient.
  • CC remains early and can be unstable.
  • Net: treat it as an assistant, not a crutch.

3) Technical PMs / founders / CEOs: newfound leverage

Section titled “3) Technical PMs / founders / CEOs: newfound leverage”
  • PMs, founders, and CEOs call it “finally a way to quickly ship ideas stuck in my head.”
  • Many ideas you might hesitate to “ask the team to build” can be prototyped solo with CC, such as:
    • Personalized feed apps
    • Note‑taking utilities
    • Small Apple Watch data parsers
    • Personal sites
  • In enterprises, CTOs experiment with LLM add‑ons for legacy systems — smart support, recommendations, and more.
  • Intercom’s example: Claude Code “lets us build things we never had time for — from AI data‑labeling tools to an ROI calculator for sales.”

Using Claude Code for Internal System Integration

Section titled “Using Claude Code for Internal System Integration”

⚡ Rapidly integrating heterogeneous systems

Section titled “⚡ Rapidly integrating heterogeneous systems”
  • CC excels at automating drudgery: fixing lint, resolving merge conflicts, drafting release notes.
  • It can quickly scaffold glue code across APIs, databases, and filesystems, enabling fast experiments.

🤖 Injecting LLM intelligence into legacy systems

Section titled “🤖 Injecting LLM intelligence into legacy systems”
  • CC can generate integration layers for LLM capabilities and wrap natural‑language skills into existing systems.
  • Examples: internal knowledge‑base chatbots; CRM smart‑recommendation modules.
  • CC can “stay aware of the whole project structure,” and via MCP pull data from Google Drive, Figma, Slack, etc.

👉 Positioning: an accelerator, not a replacement. You still need monitoring, tests, and mature architectures.


  • LLMs are probabilistic; outputs won’t be correct every time.
  • For tasks like global renaming, “let the IDE’s refactor tools do it” is often safer.
  • Community feedback: CC performs better on web/front‑end than on Swift/iOS.
  • Bottom line: great as an assistant; not a fully automated path to production‑grade software.
  • Individual subscriptions are manageable; organization‑wide costs add up.
  • Reported averages: roughly ~$6 per person per day; with Sonnet 4, team costs can run $100–$200 per person per month.
  • Pricing: Pro ~ $17/month; Max up to $200/month.
  • Conclusion: fine for personal dev; building products/services purely via API usage can get expensive.

  • Creative prototypes and personal projects: quickly assemble small apps, algorithm prototypes, or validation scripts.
    • Hundreds of lines of code in minutes.
  • Understanding and refactoring complex codebases: analyze logic, sketch architecture maps, propose global improvements.
  • Everyday acceleration and automation: generate tests/docs, fix formatting, go from issue to patch PR.

👉 Best practice: Human + AI collaboration. Humans steer; AI accelerates.


ToolTraitsBest‑fit scenariosLimits
Claude CodeTerminal agent; strong reasoningDeep debugging; large codebases; creative prototypingCost; imperfect reliability
GitHub CopilotIDE plugin; code completionEveryday small‑step codingWeak at global planning; not great for 0→1
Cursor (Editor)VS Code‑like, AI‑enhancedIDE‑centric workflows; front‑endAgent mode feels heavy; middling stability
Cursor CLICLI, multi‑modelFlexible; supports Anthropic/OpenAI/GoogleBeta; stability varies
OpenAI Codex CLITerminal AI agent; multimodalDebugging; automation; open and flexibleStill evolving; code quality varies
Google Gemini CLIFree/open; long contextBig projects; low budgets; broad tasksEcosystem younger; shallower reasoning depth

  • Best‑suited users:
    • Technically literate PMs / founders / CEOs: turn ideas into reality fast.
    • Dev teams: internal integrations and LLM experiments.
  • Less suited:
    • Complete beginners (barrier too high).
    • Senior architects who need rigor and determinism (use CC as an aide, not a driver).

Claude Code isn’t a silver bullet, but in the Vibe Coding arena it helps more ideas leap from mind to reality. The winner of this AI developer‑productivity race will be whoever best balances cost with reliability.


Stop Arguing — Ship with Claude Code: Turn Newcomers and Engineers into One Team

Claude Code pushes the long‑running trend of “write less code, get more done” to the extreme. Writing code is only a slice of engineering. Dialogue and collaboration help both “non‑coders” and engineers convert Unknown Unknowns into Known Unknowns — that’s how Claude Code becomes real productivity.


A discussion has been making the rounds: some say LLMs let “non‑coders” ship small software; professional engineers counter that software engineering is much more than code — requirements, architecture, integration, and long‑term maintenance. Both sides are right — just speaking from different vantage points. Behind the debate is a decades‑long industry arc of “writing less code,” and Claude Code is simply the next turn of the crank.


Software has steadily reduced mechanical work:

  • Rails scaffolding: one command generates MVC; prototypes get moving fast.
  • Protocol Buffers: efficient cross‑language RPC without bespoke serialization code.
  • Scala implicits/given: use the type system to remove boilerplate and glue.

LLMs extend that same trajectory: write less code, accomplish more. But the “engineering” never goes away.


  • It lives in your terminal — not just another chat box.
  • It takes action: edits files, runs commands, creates commits.
  • It integrates with external systems via MCP (read design docs, update Jira, use custom tools).

Automation also moves into CI/CD: GitHub Actions can @claude in PRs/Issues to auto‑review, branch, and propose fixes.

On the ground, enterprise rollout is happening — teams can assign standard or advanced Claude/Claude Code seats with central management and tracking.


3) Why do “non‑coders” feel empowered?

Section titled “3) Why do “non‑coders” feel empowered?”

Because this time AI offers them a usable interface:

  • PMs can spin up prototypes in natural language and surface ambiguities earlier.
  • Ops/design can tweak small features or scripts directly without waiting in backlogs.

Media are observing the same trend. “Vibe Coding” — programming closer to intent, less fixation on code — is heating up. Reporters have done pair‑coding sessions and, in two days, shipped small UI and feature changes. The term took off in early 2025.


Durability and control:

  • Architectural boundaries, data contracts, performance budgets, observability — none of these are solved by “a couple snippets.”
  • Tests and acceptance criteria must be explicit. Tools like Cucumber/Gherkin let you write business‑readable, executable acceptance tests that AI can also help generate and maintain.

In short: AI can help us write less code, but the engineering organization and constraints must be stronger.


  1. Equating programming with “the act of typing code.”
  2. Assuming a small app stitched together with AI represents how the industry builds software — therefore, the industry will be replaced.

These crop up among junior developers too. Experience teaches that the core of software engineering is the “engineering.”


6) Stop arguing: adopt a collaboration playbook

Section titled “6) Stop arguing: adopt a collaboration playbook”

Goal: turn Unknown Unknowns into Known Unknowns. Use this minimal loop — a team can adopt it today.

  • Write five Gherkin acceptances (Feature/Scenario). PMs/business own the prose; engineers ensure testability.
  • Let Claude Code read the .feature files and draft a minimal implementation plus test skeletons.

2) Start with Claude Code — don’t end there

Section titled “2) Start with Claude Code — don’t end there”
  • Have it generate prototypes and PRs, but keep merge authority with a responsible owner.
  • Add “gate rules” for critical modules: merges require passing baseline tests and performance budgets.
  • In GitHub Actions, trigger @claude suggestions/fixes on new Issues, failed CI, or specific labels.
  • Have it produce risk notes and rollback templates to reduce merge anxiety.
  • Via MCP, allow Claude to read design docs and ADRs (architecture decision records).
  • PRs must update ADRs and interface contracts (Proto/JSON Schema). Keep the trio “code–contract–tests” consistent.
  • Weekly human+AI code review to curate an “AI blind‑spots list.”
  • Track failure and rollback rates separately for “AI‑authored changes” and use data to set scope and limits.

Bringing “non‑coders” into the loop is good — they sit close to the business and push 0→1. Having engineers own boundaries and constraints is necessary — that’s how systems run long and run stable. Arguments won’t close the loop; collaboration will.

Next step: take a 3–5 day feature in your product and run it through the collaboration playbook above. After a retro, decide how far to open the gates for Claude Code.


Suggested illustrations (2:1, no Chinese text)

Section titled “Suggested illustrations (2:1, no Chinese text)”
  1. Cover: a PM and an engineer high‑five in front of a terminal; the screen shows CLI, PRs, Gherkin scenario cards, and an AI helper icon; warm tech illustration with ample whitespace.
  2. Key sections:
    • “History of writing less code”: icons for Rails scaffolding, Proto contracts, Scala given/implicit on a timeline.
    • “Claude Code capabilities”: terminal UI + file tree + Git commit arrows + connectors to Jira/Drive.
    • “Collaboration playbook”: five cards (Acceptance → Prototype → CI → Contracts → Retro) arranged like a kanban.

  • How much permission should Claude Code have in your team, and why?
  • Any real cases where AI caused issues? How did you harden the process afterward?

    • Simplified Chinese: 别吵了,用 Claude Code 开工吧:把“门外汉”与工程师变成一支队
    • English: Stop Arguing — Ship with Claude Code: Turn “Newcomers” and Engineers into One Team
    • Traditional Chinese: 別吵了,用 Claude Code 開工吧:把「門外漢」與工程師變成一支隊
    • Japanese: 議論はもうやめて、Claude Codeで出荷しよう。素人とエンジニアを“一つのチーム”に
    • French: Assez de débats — Livrez avec Claude Code : unissez « non‑codeurs » et ingénieurs
    • Spanish: Basta de discutir: entrega con Claude Code y une a « no técnicos » e ingenieros
    • Portuguese: Chega de briga: entregue com Claude Code e una « não técnicos » e engenheiros
    • slug: stop-arguing-ship-with-claude-code
    • Simplified Chinese: 写得少,做得多:Claude Code 如何把争论变成协作
    • English: Write Less, Ship More: How Claude Code Turns Debate into Collaboration
    • Traditional Chinese: 寫得少,做得多:Claude Code 如何把爭論變成協作
    • Japanese: 書く量を減らして成果を増やす:Claude Codeが“論争→協業”に変える方法
    • French: Écrire moins, livrer plus : Claude Code transforme les débats en collaborations
    • Spanish: Escribe menos, entrega más: Claude Code convierte el debate en colaboración
    • Portuguese: Escreva menos, entregue mais: Claude Code transforma debate em colaboração
    • slug: write-less-ship-more-claude-code
    • Simplified Chinese: Vibe Coding 落地指南:把 Unknown Unknowns 变成 Known Unknowns
    • English: Vibe Coding Playbook: Turn Unknown Unknowns into Known Unknowns
    • Traditional Chinese: Vibe Coding 落地指南:把 Unknown Unknowns 變成 Known Unknowns
    • Japanese: Vibe Coding実践:Unknown UnknownsをKnown Unknownsへ
    • French: Guide Vibe Coding : transformer les inconnues inconnues en inconnues connues
    • Spanish: Guía de Vibe Coding: de incógnitas desconocidas a incógnitas conocidas
    • Portuguese: Guia de Vibe Coding: do desconhecido‑desconhecido ao conhecido‑desconhecido
    • slug: vibe-coding-playbook-unknowns

  1. This nails the real friction: AI doesn’t replace engineering — it amplifies collaboration. Saving this and running a small feature with @claude + Gherkin.
  2. Just enabled @claude + Gherkin in our repo — speed unlocked. From now on: write acceptance first, then code.
  3. Non‑coders × engineers is the winning combo. Next time the “replacement” debate comes up, I’ll share this piece.

Use Claude Code + GitHub Actions to Make @claude Your Automated Teammate

Mention @claude right inside PRs, Issues, and scheduled jobs. It follows your repo’s CLAUDE.md to review code, fix bugs, implement small features, and even post daily reports — all on GitHub‑hosted runners with zero server ops.


Ever felt this? PRs pile up and reviews lag; Issues are clearly described, yet no one wants to take the first swing.

With Claude Code’s GitHub Actions, a single @claude hands off those repetitive but necessary tasks. It reads context, adheres to your project conventions, and can create or update PRs — even propose implementations.


  • @claude on demand: mention it in PR/Issue comments to trigger either “interactive replies” or “auto‑execute” — v1 auto‑detects which to use.
  • Aligns to your team norms: put a CLAUDE.md at the repo root with code style, review rules, and common patterns; Claude follows it during execution.
  • Multi‑cloud options: use Anthropic API directly or route via AWS Bedrock / Google Vertex AI to match enterprise compliance and billing.
  • Extensible SDK: the official Claude Code SDK supports Headless/TS/Python so you can embed a “code‑writing agent” into various workflows.
  • No infra to manage: defaults to GitHub‑hosted runners; private repos consume Action minutes, public repos are free.

  1. Open the Claude app in your terminal and run: /install-github-app.
  2. Follow prompts to install the GitHub App and configure the ANTHROPIC_API_KEY secret.
  3. Test by mentioning @claude in a repo comment.

If that path doesn’t work, use manual install: install the official GitHub App → add ANTHROPIC_API_KEY to the repo → copy examples/claude.yml to .github/workflows/.

B. Upgrade from Beta to v1 (breaking changes)

Section titled “B. Upgrade from Beta to v1 (breaking changes)”
  • Action version: @beta@v1
  • Remove the mode: config (v1 auto‑detects)
  • direct_prompt renamed to prompt
  • CLI flags move under claude_args (e.g., --max-turns, --model, --system-prompt)

1) Comment‑mention code review with @claude

Section titled “1) Comment‑mention code review with @claude”
name: Claude Code (mentions)
on:
issue_comment: { types: [created] }
pull_request_review_comment: { types: [created] }
jobs:
run:
runs-on: ubuntu-latest
steps:
- uses: anthropics/claude-code-action@v1
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
# leave prompt empty to auto-respond to @claude

Behavior: when someone comments @claude this code may have a concurrency issue; suggest and fix, the Action reads context, replies, and, if appropriate, commits changes.

name: Code Review
on:
pull_request: { types: [opened, synchronize] }
jobs:
review:
runs-on: ubuntu-latest
steps:
- uses: anthropics/claude-code-action@v1
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
prompt: "/review"
claude_args: "--max-turns 5"

Explanation: on new or updated PRs, trigger a light /review, limiting turns to contain token usage.

name: Daily Report
on:
schedule: [{ cron: "0 9 * * *" }]
jobs:
report:
runs-on: ubuntu-latest
steps:
- uses: anthropics/claude-code-action@v1
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
prompt: "Summarize yesterday's commits and open issues"
claude_args: "--model claude-sonnet-4-20250514"

Explanation: scans recent commits and open issues, posts a daily summary to a comment or new issue.


Section titled “Recommended use cases (real time‑savers)”
  • Security reviews and compliance checklists: add a minimum‑bar privacy/security review to PRs.
  • Bug reproduction and small fixes: describe an error in a comment and have @claude reproduce, locate, and submit a narrow fix.
  • Unit‑test completion: auto‑add missing tests for critical modules, guided by your CLAUDE.md style.
  • Multi‑repo refactors: with SDK/headless mode, batch “unify scaffolds, upgrade deps, replace legacy functions.”
  • Enterprise cloud compliance: if you need data residency or specific billing, switch to Bedrock/Vertex paths to unify identity and audit.

Write a solid CLAUDE.md (so AI understands your project)

Section titled “Write a solid CLAUDE.md (so AI understands your project)”

Place CLAUDE.md at the repo root with:

  • Code style and directory conventions
  • Commit message format (e.g., Conventional Commits)
  • Preferred implementation patterns and anti‑patterns for components/services
  • Review checklist: security, performance, testability, observability
  • Reference links (allow @file references to key docs/examples)

Tip: keep CLAUDE.md short and sharp. Clarity drives stable outputs. Offload length to linked docs or @file attachments.


Cost and security (what leaders care about)

Section titled “Cost and security (what leaders care about)”

Cost control:

  • Public repos use hosted runners for free; private repos consume minutes and storage.
  • Set --max-turns to cap dialog length; add timeouts and concurrency limits.
  • Schedule jobs off peak; reduce unnecessary triggers; manage artifact retention.

Security:

  • Keep API keys in Secrets and reference with ${{ secrets.ANTHROPIC_API_KEY }} — never hardcode.
  • Least privilege: grant your GitHub App only the permissions it needs; audit CI trigger events.

  • Custom GitHub App: for brand/permissions control, create a tenant‑specific App and authenticate via create-github-app-token.
  • Faster runners: for large repos or heavier tasks, consider self‑hosted or accelerated runners to reduce job time and cost.
  • SDK pipelines: use the Claude Code SDK to orchestrate “read repo → generate patch → verify → open PR” as your engineered agent.

The busier your team, the more you benefit from a reliable “automated teammate.” Put conventions in CLAUDE.md and workflows in GitHub Actions, and hand the tedious yet critical chores to Claude — freeing people to create higher‑value work.

Which workflow will you hand to @claude first? Share your ideas or pass this guide to a teammate and try it today.


Title options and slugs (multi‑language)

Section titled “Title options and slugs (multi‑language)”
  1. Plug @claude into GitHub Actions: Your Automated Teammate Is Live

    • slug: claude-code-github-actions-automated-teammate
  2. One Comment, One Delivery: Claude Code × GitHub Actions in Practice

    • slug: one-comment-one-delivery-claude-code-github-actions
  3. Offload Reviews, Fixes, and Reports to AI: A GitHub Actions Guide

    • slug: ai-reviews-fixes-reports-github-actions-guide

Illustration prompts (2:1, no Chinese text)

Section titled “Illustration prompts (2:1, no Chinese text)”
  • Cover: a developer types “@claude” in a GitHub PR while an AI assistant materializes task cards like “Review”, “Fix tests”, and “Create PR”; clean pastels, minimal UI, soft shadows, 2:1.
  • Section art:
    1. Flow: GitHub comment → Claude analysis → PR update; flat modern arrows and cards, 2:1.
    2. A CLAUDE.md style guide pinned with checkmarks for security, tests, performance; 2:1.
    3. Bedrock & Vertex AI icons connecting to GitHub Actions runners; compliance shield; 2:1.

Claude Code with GitHub Copilot Sonnet Model

Scenario: Claude Code runs out of quota right when you need it, but you happen to have a GitHub Copilot subscription. By using an open-source Copilot API proxy that exposes Copilot as an OpenAI/Anthropic compatible API, you can plug Claude Code into it and keep Vibe Coding. This guide walks you through setup and recommends safer, more compliant usage.


This is a reverse‑engineered GitHub Copilot API proxy that turns Copilot into an OpenAI-compatible /v1/chat/completions service and an Anthropic-compatible /v1/messages service. The upside: any tool supporting those APIs can use it—including Claude Code. The project ships with usage dashboards, rate limiting, manual approval, and support for Business/Enterprise accounts.

Note: This is not officially supported by GitHub. GitHub explicitly restricts excessive automation/bulk requests, which may trigger risk controls or temporary suspension. Use at your own risk and stay reasonable.


Three practical benefits:

  • Low interruption: when Claude Code runs dry, continue writing, editing, and testing through Copilot.
  • Low friction: use OpenAI/Anthropic compatible endpoints so Claude Code switches without major changes.
  • Controllable and auditable: includes usage boards, rate limiting/wait mechanisms, and manual approvals to avoid tripping risk controls.

Prerequisite: you have an active GitHub Copilot subscription.

Terminal window
# 1) Interactive login
npx copilot-api@latest auth
# 2) Start the proxy and generate a Claude Code connect command
npx copilot-api@latest start --claude-code
# 3) Paste the suggested command in a new terminal (or set env vars manually)
ANTHROPIC_API_KEY=sk-dummy \
ANTHROPIC_BASE_URL=http://localhost:4141 \
claude --dangerously-skip-permissions

The above flow comes from the built‑in --claude-code wizard. You can also persist the environment via .claude/settings.json to avoid exporting variables every time.

More robust approach: avoid using --dangerously-skip-permissions long‑term. Prefer Claude Code’s permissions and environment settings—configure ANTHROPIC_BASE_URL, default model, and a permissions allowlist in the project’s .claude/settings.json to prevent mistakes.


  • npx one‑liner: npx copilot-api@latest start (optionally add --port 8080 --verbose)

  • Docker with persistent login: mount ./copilot-data to persist tokens so container restarts don’t lose auth.

    Terminal window
    mkdir -p ./copilot-data
    docker run -p 4141:4141 \
    -v $(pwd)/copilot-data:/root/.local/share/copilot-api \
    copilot-api

    You can pass GH_TOKEN during build/run, which works nicely in CI/CD.


Section titled “Recommended “Safe & Compliant” Posture”
  • Bind to localhost only: listen on 127.0.0.1:4141; don’t expose publicly. Use a tunnel/VPN if needed.
  • Enable rate limits: --rate-limit 30 --wait and, when appropriate, --manual for manual review to lower anomaly rates.
  • Declare account type: specify personal / Business / Enterprise via --account-type.
  • Respect the policies: read GitHub’s Acceptable Use Policies and Copilot Terms; avoid excessive automation/bulk requests.
  • Principle of least privilege: use Claude Code’s permissions.deny to block .env, secrets/**, and other sensitive paths.

  • Token/model limits: check issues related to max_prompt_tokens, oversized context, and suggested fixes.
  • Headless login: use auth to obtain a token, then pass it via --github-token.
  • Risk controls triggered: first pause automated/batch tasks, increase latency, enable --manual, then review policy compliance.

  • Good fit: individual developers and small teams with a paid Copilot plan who want a smooth backup when Claude Code quota runs low.
  • Not ideal: strict enterprise compliance environments—prefer official Claude Code integrations (e.g., Bedrock/Vertex/LLM gateways/enterprise proxies).

[Illustration suggestion | 2:1] Theme: left side “indie desk setup”, right side “enterprise server room” with a compliance shield and cloud provider badges. English prompt: Split-screen illustration: indie desk setup vs enterprise server room with a compliance shield. Minimal, 2:1.


Local quick run:

Terminal window
npx copilot-api@latest auth
npx copilot-api@latest start --rate-limit 30 --wait --claude-code
# In a new terminal, run the Claude Code start command as prompted

Project‑level environment via .claude/settings.json at repo root:

{
"env": {
"ANTHROPIC_BASE_URL": "http://localhost:4141"
},
"permissions": {
"deny": ["Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)"]
}
}

(See official settings docs for more options.)


Think of it as an emergency power pack. When timing matters, it keeps your Vibe Coding flow alive; day‑to‑day, it can serve as a low‑cost online backup. But remember—stable, compliant, least privilege is the productivity that lets you sleep well.

Will you make it your long‑term safety net, or keep it for emergencies only? What do you think?

Voice-Driven Vibe Coding on Mac with Spokenly + Claude Code

You speak, it writes, things run. Hands off the keyboard, code still flies.

Over the past two months I’ve become addicted to Vibe Coding. Pair Spokenly for voice input with Claude Code as a “capable terminal copilot”. I keep three panes open: Plan, Build, Review. I grab tea; when I’m back it’s just “acceptance” and “next steps”. Before bed I toss in a big task; next morning I check results like a ruthless boss — day’s rhythm, locked.

This guide shows the complete setup for driving Claude Code by voice on macOS with Spokenly. Install and go — you can ship tonight.


  • Spokenly: global hotkey, dictation in any input field; supports local Whisper, offline-ready; or bring your own cloud API key; Agent Mode to control your Mac by voice.
  • Claude Code: smart pair programmer in your terminal. After npm i -g @anthropic-ai/claude-code, just run claude; supports slash commands like /model /config /ide /compact, deep IDE integration with VS Code/JetBrains.
  • Voice tips: use Option+Enter or /terminal-setup for multi-line input; Esc Esc to edit the last message; run three-pane flow for Plan → Execute → Review.

1) Spokenly (speech → text)

  • Website: https://spokenly.app/ — supports on-device Apple Speech Recognition, Whisper, 100+ languages, Local-only privacy mode, Agent Mode, searchable history; Mac + iPhone.
  • App Store: free download, Pro adds cloud models; recent releases add Soniox, Parakeet v3, re-transcription on history, and more.

2) Claude Code (terminal AI)

Terminal window
# Node.js 18+
npm i -g @anthropic-ai/claude-code
cd your-project
claude

You’ll be up in 30 seconds. Supports MCP tools, running commands, editing files, creating commits, and IDE connections.

3) IDE (optional but highly recommended)

  • VS Code/Cursor/Windsurf: when launched in the integrated terminal, claude auto-installs the extension.
  • JetBrains: install the plugin and restart; from an external terminal use /ide to connect to the IDE.

Alternative: Apple’s built-in Dictation works too, but Spokenly wins on features and privacy (especially multilingual and offline Whisper).


Step 1: Configure Spokenly

  • Grant microphone permission on first launch.
  • Set a global Push-to-Talk hotkey (e.g., Right Command) in Preferences.
  • Choose Local-only to use Apple Speech Recognition — fully offline and private.
  • Enable Auto language to freely mix Chinese and English.
  • Mode: “Type at cursor” so dictated text flows into your terminal/editor like you’re typing.

Step 2: Start Claude Code

  • Run claude in your project directory.
  • Need multi-line input or long requirements?
    • Use Option+Enter for multi-line; or run /terminal-setup to bind Shift+Enter to newline.
  • In IDEs: start claude in an external terminal, then /ide to connect to VS Code/JetBrains to enable selection context, IDE Diffs, and more.

Step 3: Start talking

  • Focus the Claude input box → hold PTT hotkey to speak → release to send.
  • Need to tweak the last line? Press Esc Esc to edit and resend.

3) The three-pane Vibe Coding flow: Plan | Build | Review

Section titled “3) The three-pane Vibe Coding flow: Plan | Build | Review”

Pane A: Architect (Plan)

  • Say: “Add OAuth login to a Next.js project. First provide a task list and file-change plan, each step within 20 lines.”
  • Commands: use /model to pick the model; /compact to compress context and keep focus.

Pane B: Builder (Implement)

  • Say: “Follow pane A’s plan. Write code and self-test; if errors occur, fix automatically; run scripts when needed.”
  • For structure, dictate with Option+Enter: “Block 1 is the API route; Block 2 is the UI component…”

Pane C: Reviewer (Review)

  • Commands: /review, /cost for token/cost; if needed, use /config to constrain tools and scope.
  • In IDE mode, review diffs directly in the editor for a near-native pair-programming feel.

Pro tip: use separate project directories per task to start claude. Each session history is isolated per directory for clean context switching.


4) Bedtime “overnight sprint” voice template

Section titled “4) Bedtime “overnight sprint” voice template”

Break big tasks into four spoken parts so Claude Code stays on track:

  1. Goal: one-sentence objective + success criteria
  2. Scope: which directories to touch and which to avoid (allow/deny lists)
  3. Checks: self-test scripts, lint, unit/E2E tests
  4. Deliverables: PR summary, diff, changelog

Example: “Tonight migrate the Settlement module from REST to tRPC. Only modify /server/ and /app/billing/. Run pnpm test and pnpm lint — both must pass. Output steps and risks, and provide a rollback guide.”


  • Speak structure: “Heading: … New paragraph. List: one, two, three.” Helps produce cleaner docs.
  • State constraints: “Change at most three areas, each under 30 lines.” Prevents overreach.
  • Set boundaries: “Only allow Bash: pnpm*, git*.” (combine with /config to limit tools)
  • Require checks: “After changes, run npm run test; if it fails, roll back.”
  • Mix languages: APIs and identifiers in English are recognized more accurately; Spokenly auto-detects.
  • Multi-line input: Option+Enter or /terminal-setup.
  • Edit last message: Esc Esc to revise.

  • Local-first: Spokenly’s Local-only mode keeps audio on-device; pair with offline Whisper.
  • Bring your own key: if you need cloud transcription, plug in OpenAI/Deepgram/Groq, etc., to control cost; Pro subscription simplifies setup.
  • Claude costs: use /cost to check usage; control model and thinking depth via /model.

  • Terminal newline quirks → use Option+Enter or /terminal-setup to bind Shift+Enter.
  • IDE extension not installed → run claude in the IDE’s integrated terminal; restart JetBrains; or from an external terminal use /ide to connect.
  • Dictation not landing in terminal → ensure focus on Claude input; adjust Spokenly hotkey conflicts.
  • Want Apple Dictation → System Settings → Keyboard → enable Dictation, set “Press Control key twice”.

  • “Add an export-CSV endpoint under /api/orders. First provide a plan, then write code, then run tests, showing each step.”
  • “Move state management on the payment page from Redux to Zustand. Only touch existing logic, keep UI. List 3 risk points.”
  • “Read the six modules under /server/report/, generate a dependency graph, and output a visualization script (choose d2 or mermaid).”

Voice-driving Claude Code isn’t a gimmick — it helps you reach the “clarify → deliver” state faster. The clearer you describe requirements, the steadier Claude executes — and the better the Vibe. Try the three-pane method tonight and let it handle your pre-sleep ticket.

Where does this workflow save you the most time? Share your take.

Anthropic (Claude Code’s parent) Nears $10B Funding: An Analysis

As reported by Bloomberg on August 22, 2025, leading AI startup Anthropic is reportedly close to securing a massive funding round of up to $10 billion — far above prior expectations and among the largest single financing rounds in the AI sector to date.

Based on a comprehensive review of the “Anthropic nearing a $10 billion raise” reports, this analysis applies multi‑source fact‑checking, data validation, and critical reasoning to assess the story’s truthfulness and reliability. We cross‑checked at least 15 sources and found several discrepancies and points of concern. Below, we examine factual verification, data analysis, logical consistency, incentives, market psychology, and potential risks.


Cross‑referencing Bloomberg, CNBC, TechCrunch, Reuters, and other outlets confirms that Anthropic is indeed negotiating a new funding round, but key details vary. Early reporting (e.g., Bloomberg) cited a $3–5 billion raise at a roughly $170 billion valuation, not the $10 billion some outlets repeated.

A more realistic timeline looks like this:

  • 2025‑07‑29: Bloomberg first reported Anthropic’s talks for a $3–5B round at a ~$170B valuation, led by Iconiq Capital, with a potential second lead. The company was also said to be engaging the Qatar Investment Authority (QIA) and Singapore’s GIC for participation.
  • 2025‑08‑20/21: Several outlets, including Bloomberg, updated that the target could rise to “as much as $10B,” potentially becoming one of the largest AI startup financings ever. Anonymous sources cited strong investor demand pushing the target from $5B to $10B.
  • Investor roster: Iconiq Capital as lead appears consistent across reports, but other names vary. Some mention TPG, Lightspeed, Spark Capital, Menlo Ventures, and continued outreach to QIA and GIC. These discrepancies suggest no single official confirmation yet.

Conclusion: A new Anthropic raise is real, but the size and full investor lineup remain fluid. The “doubling” from $5B to $10B hinges on anonymous sourcing and lacks formal confirmation.


Anthropic’s recent valuation path raises plausibility questions:

  • 2025‑03: Closed a $3.5B round led by Lightspeed at a post‑money of ~$61.5B.
  • 2025‑07: Rumored valuation for the new round rose to ~$170B — a 176% jump in four months.

Annualized, that implies >500% growth, a pace that typically requires extraordinary fundamentals.


Multiple sources indicate explosive ARR growth over the past year:

  • Late 2024: ~$1.0B
  • 2025‑05: ~$3.0B
  • 2025‑07: ~$4–5B

Key caveat: ARR often extrapolates “a hot month × 12,” which can materially overstate actual full‑year revenue during hypergrowth.

Anthropic appears to have material concentration in a few customers:

  • Top two customers contribute roughly ~$1.4B ARR (~28%).
  • Largest single customer is the AI coding assistant Cursor at around ~$0.5B.
  • The Claude Code product contributes nearly ~$0.4B ARR.

Loss of one or more of these anchors would significantly impact revenue.


  • Cash burn: Raising $3.5B in March and then targeting $5–10B just five months later implies very heavy spend — potentially hundreds of millions to billions per month.
  • Revenue multiple: Anthropic’s valuation/revenue multiple of ~34× vs OpenAI’s ~25× suggests a premium that’s hard to justify without clear differentiation.
  • Disclosures surfaced nearly in parallel with OpenAI financing chatter, suggesting signaling.
  • Heavy reliance on “people familiar with the matter,” with limited on‑record confirmation.
  • Media “trial balloons” can manufacture urgency and scarcity to lift headline valuations.

  • Strengths: >$80B AUM with ultra‑high‑net‑worth Silicon Valley clientele (e.g., Zuckerberg, Hoffman).
  • Questions:
    • Client‑driven preferences can influence allocation style.
    • Historically favors later‑stage steadier bets; a ~$1B single check would be unusually large.
  • QIA and GIC involvement introduces geopolitical and national‑security review complexity.
  • Management has previously voiced concerns about optics and regulatory scrutiny tied to Middle East capital, though capital intensity may force pragmatism.

  • Anthropic: Needs substantial capital to compete with OpenAI; lofty valuations help with talent, partnerships, and a potential IPO arc.
  • Investors: FOMO is acute; sovereigns emphasize strategic positioning.
  • Media: “Record‑breaking round” headlines drive traffic; anonymous sourcing lowers the bar, mixing motives.

  • Valuations decoupling from fundamentals relative to traditional tech.
  • Capital concentration: ~64% of US VC dollars in H1 2025 flowed to AI.
  • Herding behavior: Fear of missing the next ChatGPT inflates risks.

  • Moat durability: Performance gaps between Claude and GPT‑5 appear to be narrowing.
  • Business model pressure: API pricing wars and sustained compute costs weigh on margins.
  • US export controls and the EU AI Act may constrain expansion.
  • Sovereign participation could trigger CFIUS review, adding uncertainty.

  • Directionally true: Anthropic is raising capital.
  • Headline number uncertain: $10B is unconfirmed; $5B looks more likely.
  • Valuation froth: Fundamentals may not support the premium.
  • Incomplete information: Signs of selective disclosure.
  1. Stay rational about big round headlines.
  2. Prioritize actual revenue and profitability over valuation theater.
  3. Beware bubble dynamics and momentum herding.
  4. Wait for official confirmation before anchoring decisions.

In today’s AI investment cycle, media narratives, corporate signaling, and on‑the‑ground reality often diverge. In moments of mania, noise overwhelms signal. Only disciplined verification and clear‑eyed analysis can keep decisions grounded in truth instead of sentiment.

Create a Gemini Subagent in Claude Code (1M Context)

Spin up a “sub‑agent” inside Claude Code dedicated to calling the Gemini CLI. Offload heavy code scans, architecture overviews, and security audits to Gemini’s 1M‑token context; keep Claude as the brain to interpret results and land changes. Cheaper, simpler, and faster.


For repository‑wide overviews, cross‑repo search, and architecture mapping, even Claude can get bottlenecked by context size. The fix is simple: outsource large‑mouth analysis to the Gemini CLI. We’ll create a Gemini analysis subagent in Claude Code that only does three things: build commands → call the CLI → hand raw results back. Claude stays unpolluted and focused on decisions and edits — a powerful pairing.

Why now? Google open‑sourced the Gemini CLI. Personal accounts can connect to Gemini 2.5 Pro for free, with a 1M‑token context and generous preview quota. For whole‑repo analysis, it’s basically a “power‑up.”

Figure suggestion (2:1 illustration): An engineer orchestrates two robots at a console: left “Claude (planner/editor)”, right “Gemini subagent” ingesting a massive code pile. Use English UI labels only.


  • Claude (primary agent): converses, breaks down tasks, reviews, and lands changes (edit files, run tests, etc.).
  • Gemini subagent: does not analyze itself; it only turns requests into Gemini CLI commands, executes them, and returns raw output.
  • Context isolation: the subagent runs with its own context and doesn’t pollute the main chat; excellent for repeated reuse.

  1. Install Gemini CLI (pick one)
Terminal window
# Run via npx (no install)
npx https://github.com/google-gemini/gemini-cli
# Global install (npm)
npm install -g @google/gemini-cli
# Or Homebrew (macOS/Linux)
brew install gemini-cli

Requires Node.js ≥ 20. Supports OAuth login, API Key, or Vertex AI.

  1. Log in / authenticate
Terminal window
# Recommended: OAuth (personal Google account; preview quota is generous)
gemini # follow browser login flow
# Or: use an AI Studio API key
export GEMINI_API_KEY="YOUR_API_KEY"
gemini

Official posts confirm 1M context and high preview limits; the GitHub README covers OAuth / API key / Vertex options.

  1. Verify it works
Terminal window
gemini -p "Say hello and print current directory files briefly"

Create the “Gemini Analyzer” Subagent in Claude Code

Section titled “Create the “Gemini Analyzer” Subagent in Claude Code”

Claude Code lets you define subagents as Markdown with YAML frontmatter. At the project level, place them under .claude/agents/ (user‑level: ~/.claude/agents/).

Create: .claude/agents/gemini-analyzer.md

---
name: gemini-analyzer
description: Manages Gemini CLI for large codebase analysis and pattern detection. Use proactively when Claude needs to analyze extensive code patterns, architectural overviews, or search through large codebases efficiently.
tools: Bash, Read, Write
---
You are a Gemini CLI manager specialized in delegating complex codebase analysis tasks to the Gemini CLI tool.
Your sole responsibility is to:
1. Receive analysis requests from Claude
2. Format appropriate Gemini CLI commands
3. Execute the Gemini CLI with proper parameters
4. Return the results back to Claude
5. NEVER perform the actual analysis yourself - only manage the Gemini CLI
When invoked:
1. Understand the analysis request (patterns to find, architectural questions, etc.)
2. Determine the appropriate Gemini CLI flags and parameters:
- Use `--all-files` for comprehensive codebase analysis
- Use specific prompts that focus on the requested analysis
- Consider using `--yolo` mode for non-destructive analysis tasks
3. Execute the Gemini CLI command with the constructed prompt
4. Return the raw output from Gemini CLI to Claude without modification
5. Do NOT attempt to interpret, analyze, or act on the results
Example workflow:
- Request: "Find all authentication patterns in the codebase"
- Action: `gemini --all-files -p "Analyze this codebase and identify all authentication patterns, including login flows, token handling, and access control mechanisms. Focus on the implementation details and architectural patterns used."`
- Output: Return Gemini's analysis directly to Claude
Key principles:
- You are a CLI wrapper, not an analyst
- Always use the most appropriate Gemini CLI flags for the task
- Return complete, unfiltered results
- Let Claude handle interpretation and follow-up actions
- Focus on efficient command construction and execution
## Detailed Examples by Use Case
### 1. Pattern Detection
**Request**: "Find all React hooks usage patterns"
**Command**: `gemini --all-files -p "Analyze this codebase and identify all React hooks usage patterns. Show how useState, useEffect, useContext, and custom hooks are being used. Include examples of best practices and potential issues."`
**Request**: "Locate all database query patterns"
**Command**: `gemini --all-files -p "Find all database query patterns in this codebase. Include SQL queries, ORM usage, connection handling, and any database-related utilities. Show the different approaches used."`
### 2. Architecture Analysis
**Request**: "Provide an architectural overview of the application"
**Command**: `gemini --all-files -p "Analyze the overall architecture of this application. Identify the main components, data flow, directory structure, key patterns, and how different parts of the system interact. Focus on high-level organization and design decisions."`
**Request**: "Analyze the component hierarchy and structure"
**Command**: `gemini --all-files -p "Examine the React component hierarchy and structure. Identify reusable components, layout patterns, prop drilling, state management approaches, and component composition patterns used throughout the application."`
### 3. Code Quality Analysis
**Request**: "Find potential performance bottlenecks"
**Command**: `gemini --all-files -p "Analyze this codebase for potential performance bottlenecks. Look for expensive operations, inefficient data structures, unnecessary re-renders, large bundle sizes, and optimization opportunities."`
**Request**: "Identify security vulnerabilities"
**Command**: `gemini --all-files -p "Scan this codebase for potential security vulnerabilities. Look for authentication issues, input validation problems, XSS vulnerabilities, unsafe data handling, and security best practices violations."`
### 4. Technology Stack Analysis
**Request**: "Identify all third-party dependencies and their usage"
**Command**: `gemini --all-files -p "Analyze all third-party dependencies and libraries used in this project. Show how each major dependency is utilized, identify any potential redundancies, outdated packages, or security concerns."`
**Request**: "Map out the testing strategy and coverage"
**Command**: `gemini --all-files -p "Examine the testing strategy used in this codebase. Identify test frameworks, testing patterns, test coverage areas, mocking strategies, and areas that might need more testing."`
### 5. Feature Analysis
**Request**: "Trace a specific feature implementation"
**Command**: `gemini --all-files -p "Trace the implementation of [specific feature] throughout the codebase. Show all files involved, data flow, API endpoints, UI components, and how the feature integrates with the rest of the system."`
**Request**: "Find all API endpoints and their usage"
**Command**: `gemini --all-files -p "Catalog all API endpoints in this application. Include REST routes, GraphQL resolvers, tRPC procedures, their request/response patterns, authentication requirements, and how they're consumed by the frontend."`
### 6. Migration and Refactoring Analysis
**Request**: "Identify legacy code patterns that need modernization"
**Command**: `gemini --all-files -p "Identify outdated or legacy code patterns that could be modernized. Look for old React patterns, deprecated APIs, inefficient implementations, and opportunities to use newer language features."`
**Request**: "Analyze consistency across similar components"
**Command**: `gemini --all-files -p "Examine similar components or modules for consistency. Identify variations in patterns, naming conventions, implementation approaches, and opportunities for standardization or creating reusable abstractions."`
### 7. Documentation and Knowledge Transfer
**Request**: "Generate onboarding documentation insights"
**Command**: `gemini --all-files -p "Analyze this codebase to help create onboarding documentation. Identify key concepts developers need to understand, important files and directories, setup requirements, and the most critical patterns to learn first."`
### Command Flag Guidelines:
- Always use `--all-files` for comprehensive analysis
- Add `--yolo` for non-destructive analysis tasks to skip confirmations
- Use `-p` for single prompts or `-i` for interactive sessions
- Consider `--debug` if you need to troubleshoot Gemini CLI issues

Subagent file format, placement, and available tools (Bash/Read/Write) follow the official docs.

Tip: You can also create/edit subagents interactively via /agents.


Permissions and Safety: “Green‑light” the Subagent

Section titled “Permissions and Safety: “Green‑light” the Subagent”

To let the subagent run gemini smoothly, whitelist the relevant Bash calls in .claude/settings.json, and strictly blacklist sensitive reads:

{
"permissions": {
"allow": [
"Bash(gemini*)",
"Read(**/*.md)",
"Read(src/**)"
],
"deny": [
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)",
"Bash(curl:*)"
]
}
}

The permission system and examples follow Claude Code’s official Settings docs.


Usage: talk to the primary agent in Claude Code, e.g., “Have the gemini-analyzer subagent scan the whole repo’s authentication implementation and return the raw output.

1) Pattern search: authn/authz implementations

Section titled “1) Pattern search: authn/authz implementations”

Claude instruction

Use the gemini-analyzer subagent to analyze authentication patterns across the repo and return raw output.

Subagent command (example)

Terminal window
gemini -p "Analyze this codebase and list all authentication & authorization patterns: login flows, token/session handling, middleware/guards, RBAC/ABAC, and any security pitfalls. Show file paths and code excerpts when helpful."

-p runs a non‑interactive, one‑shot analysis. Run at the repo root so Gemini reads the project context; optionally add --include-directories for extras.


2) Architecture bird’s‑eye: components and data flow

Section titled “2) Architecture bird’s‑eye: components and data flow”

Claude instruction

Use gemini-analyzer to provide a high‑level architectural overview and return the raw result.

Subagent command

Terminal window
gemini -p "Give an architectural overview: main modules, data flow, directory structure, cross-cutting concerns, and how backend APIs connect to frontend components. Output a concise map with file references."

Large context is ideal for whole‑repo maps and cross‑layer traces — perfect for the Gemini CLI’s 1M tokens.


Claude instruction

Ask gemini-analyzer to scan for potential security issues and return raw findings.

Subagent command

Terminal window
gemini -p "Scan for potential security issues: XSS, SQL/NoSQL injection, hard-coded secrets, weak crypto, unsafe deserialization, missing input validation, authz gaps. Provide evidence snippets and file paths."

The subagent returns raw output only; Claude interprets it and prepares fix PRs.


  • One‑liner role hint: put “Use proactively” in description so Claude will automatically delegate big jobs.
  • Cost/speed toggle: during exploration, try -m gemini-2.5-flash; once direction is right, switch to -m gemini-2.5-pro for a deep pass.
  • Fixed templates: keep common prompt snippets like “dependency map” and “test coverage report” for stable reuse.
  • Clean context: subagent and main chat are separated, preventing huge scans from bloating the main thread.
  • Least privilege: only allow necessary Bash/Read rules; deny sensitive files decisively.
  • Don’t panic on errors: if commands fail, retry with --debug and return logs verbatim for Claude to triage.

This Claude brain + Gemini subagent combo is ideal for whole‑repo sweeps, architecture health checks, migration assessments, and dependency cleanup. You stay in Claude Code and hand heavy lifting to Gemini. You save money and time. The next time you need “wide view + grounded action,” run them together.

Where would you use this? Share your scenarios — I can help further refine the subagent prompts for your case.

Do Vibe Coding Right with Claude Code: A FAANG Engineer’s Practical Pipeline

This year, Silicon Valley gave a name to a style of coding: Vibe Coding. It’s not slacking off, and it’s not “let the AI do everything.” It’s using Claude Code as a “disciplined junior engineer” so teams ship faster and more reliably.

An agentic coding assistant in your terminal: it plans, reads/writes your project, runs commands, and uses slash commands to codify your workflow.


FAANG‑Style “Vibe Coding” Best Practices (copy straight into your team)

Section titled “FAANG‑Style “Vibe Coding” Best Practices (copy straight into your team)”

Goal: Treat Claude as an orchestratable junior engineer. Humans own architecture and decisions; AI executes and reports progress.

  • Write a design doc covering architecture, boundaries, integration points.
  • Do a senior‑engineer review to front‑load the pain. This prevents the AI from “speeding you off course” later. (Pattern lifted from FAANG workflows.)
  • For each feature, enter plan‑mode once, generate a task list, then execute against that list. Stability improves dramatically. Community experience shows this “rigid sequence” shifts Claude from “occasionally off the rails” to “reliably intern‑like.”
  • Give Claude your business rules → generate unit/integration tests → human review → then let it implement code.
  • Multiple write‑ups emphasize: tests first slashes hallucinations and regressions.

4) Codify your workflow with slash commands

Section titled “4) Codify your workflow with slash commands”

Turn frequent actions into reusable commands:

  • /spec to generate a feature spec
  • /tests <feature> to produce TDD tests
  • /implement <feature> to commit a PR strictly by the task list
  • /context to inspect context usage and tool calls Official support includes custom commands and namespaces, so you can bake the team process into the repo.
  • Do one thing at a time; constrain directories and files; pipe logs/CSVs to Claude when needed; let it fetch data or read links when appropriate.
  • Two‑person review plus staging verification, as used in FAANG.
  • Run /security-review in the terminal for an ad‑hoc security scan before you submit.
  • Track lead time from proposal → production and your regression rate. Many report ~30% faster, but measure against your own baseline.

Our minimal rollout pack (copy into your repo)

Section titled “Our minimal rollout pack (copy into your repo)”

Create .claude/commands/ in the repo root:

.claude/commands/spec.md
You are a Staff Engineer. Convert the user story into a crisp spec:
- Problem, Scope, Non-goals
- Architecture sketch & interfaces
- Risks & open questions
Return Markdown only.
.claude/commands/tests.md
You are a TDD coach. For <feature>, generate unit & integration tests first.
- Cover edge cases, error handling, contracts
- Use the project’s test framework
- Do NOT implement code yet
.claude/commands/implement.md
Follow the approved plan. Implement <feature> with tiny commits.
- Reference related tests
- Explain changes in the PR body
- Ask before migrating schemas

Combine with /context to watch tokens and tool usage; split work when needed.


  • Treating Claude as a black box, dumping a huge blob of requirements in one go.
  • Skipping tests and reviews, shipping on “it runs on my machine.” Quality drifts, and orgs fall into the “AI speed trap.”
  • Running plan‑mode in parallel for multiple features → context drift and rework.

  • The direction is clear: developers are rapidly embracing AI, and automation in coding/testing is rising. Teams who wield AI well will compound their advantage.
  • To win on quality, you must bake engineering process into Claude’s commands and plans — not “chat casually and let it write.”

Vibe Coding isn’t laziness. It’s “human judgment + Claude execution” assembled into a measurable, auditable, reusable pipeline. Starting today, give your team: design first → one‑time plan‑mode → tests first → slash‑command codification → security + review to close. Fast and steady.

What’s missing from this pipeline for your team? Share your experience in the comments.

ccpm Enables Claude Code: PRD → Epic → GitHub Issues → Production Code

ccpm (Claude Code PM) connects PRD → Epic → GitHub Issues → Production Code in a closed loop, paired with Git worktree and parallel sub-agents to ensure you don’t lose context, don’t block tasks, don’t bury landmines.


In AI coding, two things are most feared: context evaporation and parallel chaos. The result is rework, conflicts, and invisible progress.

ccpm’s approach is very “engineering-oriented”: use GitHub Issues as the single source of truth, where every line of code can be traced back to specifications. Claude only handles execution, while state, dependencies, and auditing all reside in Issues, allowing the entire team to seamlessly hand off work.

Core Philosophy: No Vibe Coding - all code must be traceable to clear specifications.


  • Specification-Driven: Structurally decompose PRDs into Epic/Tasks, then sync to GitHub Issues. Full traceability across the chain.
  • Parallel Execution: One Issue isn’t one person, but multiple parallel workflows (DB, API, UI, testing…) progressing concurrently in isolated worktrees.
  • Context Preservation: Main thread only orchestrates; each agent works in its own small context without mutual contamination.
  • GitHub Native Collaboration: Issue = project status; comments = audit trail; multiple humans/AI agents can hand off in real-time without “what did AI do” meetings.

Bonus: ccpm recommends installing the gh-sub-issue extension to manage parent-child tasks; without the extension, it automatically falls back to task lists and still works.


PRD → Epic → Task → GitHub Sync → Parallel Execution Typical command flow (in Claude Code):

Terminal window
/pm:prd-new memory-system
/pm:prd-parse memory-system
/pm:epic-oneshot memory-system
/pm:issue-start 1235

Each step produces artifacts: .claude/prds/*.md, epics/*/epic.md, task markdown files, and corresponding GitHub Issues.


  • Issues as “Database”: Status is Issue status; comments are naturally audit trails. Transparent with zero learning curve.
  • Multi-Agent Parallelism: Same Issue can spawn multiple concurrent workflows, significantly boosting throughput.
  • Worktree Isolation: Each parallel track gets its own branch/directory, drastically reducing conflicts and context pollution.
  • Commands as Process: From /pm:prd-new to /pm:issue-sync, crystallize PM habits into executable commands.
  • Fast Local, Stable Cloud: Files locally first, then explicit sync to GitHub, balancing speed with control.
  • Parent-Child Task Management: Supports GitHub Sub-issues (extension or native API), clear hierarchy with explicit dependencies.

Recommend cloning ccpm to your project root directory, or copying the .claude directory into existing projects. Run initialization on first use.

Step 1 | Copy Template

Terminal window
cd /path/to/your-project
git clone https://github.com/automazeio/ccpm.git .

If you already have CLAUDE.md, you can use /re-init later to merge necessary rules.

Step 2 | Initialize in Claude Code

Terminal window
/pm:init

This will: install/verify GitHub CLI, login, install gh-sub-issue extension, create necessary directories, update .gitignore, generate CLAUDE.md.

Step 3 | Warm Up Context

Terminal window
/context:create

Now you can start new features:

Terminal window
/pm:prd-new your-feature

PRD → Epic → Tasks → Issues complete artifact pipeline with one command.

gh-sub-issue installation command (optional but highly recommended):

Terminal window
gh extension install yahsan2/gh-sub-issue

Supports creating/linking/listing/removing sub-tasks.


  • PRD: /pm:prd-new, /pm:prd-parse, /pm:prd-list, /pm:prd-status
  • Epic: /pm:epic-decompose, /pm:epic-oneshot, /pm:epic-sync, /pm:epic-show
  • Issue: /pm:issue-start, /pm:issue-sync, /pm:issue-status, /pm:issue-close
  • Workbench: /pm:next, /pm:status, /pm:standup, /pm:blocked All built into ccpm’s command set, type /pm:help for summary.

  • 0-to-1 MVP: Ungrounded PRDs are the worst. ccpm uses commands to anchor “ideas” to Issues and code.
  • Multi-person Parallel Iteration: Split same Epic into multiple pipelines, UI/API/DB/testing progressing simultaneously, reducing serial waits.
  • Legacy Project Refactoring: Write risk points into PRD → Epic, gradual switching and rollback with traceable records.
  • Outsourcing/Remote Collaboration: Issues as project middleware, client and vendor can plug in/out anytime with transparent delivery.
  • Code Audit/Compliance: Complete “spec → code → commit → comment” chain, audit-friendly.

The author also shares design motivations and practical experiences in blogs and communities, worth reading.


  • Use “main thread” as command center: Only place goals, progress, blockers; leave implementation details to sub-agents’ contexts.
  • Leverage /pm:next: Switch to next most important Issue anytime, maintaining team rhythm.
  • Install Sub-issues first: After parent-child tasks are clear, burndown charts, daily reports, cross-person collaboration all flow smoothly.

  • Works without extensions too, but parent-child hierarchy degrades to task lists; installing gh-sub-issue makes experience much smoother.
  • Don’t pile everything into main session: Let each agent “sweep their own doorstep” in their own context, main thread only makes decisions.

I summarize ccpm’s definition in 8 characters: specifications grounded, parallelism ordered. Not relying on slogans, but on commands and deliverables, speaking through action.

If you’re stuck with “lost context, parallel conflicts, invisible progress,” it’s worth trying immediately.

Which type of problem do you most want to solve with ccpm? Let’s chat in the comments.

Wire Claude Code into Cursor, VS Code, and JetBrains

Many people install Claude Code but only use it from an external terminal. In fact, it already integrates with mainstream IDEs: Cursor / VS Code / Windsurf / VSCodium / the JetBrains family. The benefits are immediate: one‑key summon, in‑IDE diff view, automatic sharing of selections and diagnostics — and after changes, you can review them with the IDE’s native comparison tools.


  • Quick summon: Cmd+Esc (macOS) or Ctrl+Esc (Windows/Linux).

  • In‑IDE diff: cleaner before/after comparisons — no more scrolling terminals.

  • Auto‑share selection/current file context: Claude understands exactly what you’re looking at.

  • Auto‑share diagnostics (lint/syntax errors): Claude follows those red squiggles.

  • Insert file references: Cmd+Option+K (macOS) or Alt+Ctrl+K (Win/Linux) to insert @File#L1-99 quickly.

All of the above comes from the official IDE integrations.


VS Code (Cursor/Windsurf/VSCodium) One‑Step Setup

Section titled “VS Code (Cursor/Windsurf/VSCodium) One‑Step Setup”

Install and connect

  1. Open the IDE’s integrated terminal.
  2. At the project root, run:
Terminal window
claude

VS Code and its variants will auto‑install the extension, then you can use everything listed above inside the IDE. If you start from an external terminal, type /ide to connect Claude Code to the current IDE.

Make sure the CLI works

  • VS Code: run Shell Command: Install ‘code’ command in PATH from the command palette. This stabilizes code . and IDE detection for Claude.
  • Cursor: run Install ‘cursor’ to shell from the command palette (you can also install code). If PATH ordering looks off, adjust priority.

Common config

  • Run /config → set Diff tool to auto to use the IDE’s diff view automatically.
  • From any external terminal, you can still use /ide to bind to the IDE session.

JetBrains (IntelliJ / PyCharm / WebStorm / GoLand…)

Section titled “JetBrains (IntelliJ / PyCharm / WebStorm / GoLand…)”

How to use

  • Open a terminal at the project root and run claude.

  • Go to Settings → Tools → Claude Code [Beta] and adjust:

    • Claude command (e.g., claude, /usr/local/bin/claude, or npx @anthropic/claude).
    • WSL users can set: wsl -d Ubuntu -- bash -lic "claude" (replace Ubuntu with your distro).
  • Supports Cmd+Esc/Ctrl+Esc quick summon, diagnostics sharing, and in‑IDE diff.

ESC doesn’t interrupt? In JetBrains, ESC may be bound to “switch focus back to editor”:

  1. Settings → Tools → Terminal
  2. Uncheck “Move focus to the editor with Escape,” or remove the “Switch focus to Editor” keybinding.
  3. Apply Now ESC can properly interrupt Claude’s actions.

Remote Dev tips For JetBrains Remote Dev, install the Claude Code plugin on the remote host and restart the IDE.


  • VS Code extension didn’t install

    • Make sure you ran claude inside the VS Code integrated terminal.
    • Ensure code/cursor/windsurf/codium CLIs are available and allowed to install extensions.
  • JetBrains plugin “does nothing”

    • Ensure you started claude from the project root.
    • Check the plugin status and fully restart the IDE (restart twice if needed).
    • For Remote Dev, confirm the plugin is installed on the remote.
  • Workflow tips

    • Open your IDE and run claude from the same project root to share paths and file context.
    • Use /config to set diff=auto, and enable /vim mode if you like; both are recommended by the official “best practices.”

Your Quick Integration Checklist (Save This)

Section titled “Your Quick Integration Checklist (Save This)”

VS Code/Cursor

Terminal window
# 1) Use the integrated terminal
claude
# 2) From an external terminal, attach to IDE
/ide
# 3) VS Code: install 'code' into PATH (command palette)
Shell Command: Install 'code' command in PATH
# 4) Cursor: install 'cursor' into shell (command palette)
Install 'cursor' to shell

JetBrains

Settings → Tools → Claude Code [Beta]
- Claude command: claude or npx @anthropic/claude
- WSL: wsl -d Ubuntu -- bash -lic "claude"
Settings → Tools → Terminal
- Disable ESC focus steal: uncheck “Move focus to the editor with Escape,”
or remove the “Switch focus to Editor” binding

A Small‑Team Rollout Pattern (Battle‑Tested)

Section titled “A Small‑Team Rollout Pattern (Battle‑Tested)”
  • PR‑driven: define the requirement → run claude on a branch to plan and make changes → review diffs in the IDE → test locally → open a PR.
  • Pair‑Agent: humans steer the plan; Claude executes; the IDE shows diffs and diagnostics in real time.
  • Same root, same context: always start from the project root so everyone shares identical paths and context. The above blends official “best practices” with our daily experience.

Installing the tool isn’t the goal — closing the human‑AI loop inside the IDE is. Today, connect Claude Code to your Cursor/VS Code/JetBrains and try the full loop: quick summon → in‑IDE diff → diagnostics sharing → PR. You’ll likely find: cleaner changes, fewer words, faster cadence.

Question: Where does your team struggle more — “understanding legacy code” or “safely changing a big module”? Which extra step would you want Claude to take inside the IDE? Share your thoughts.

Uzi Runs Multiple AI Agents in Parallel: Claude Code, Codex, Cursor CLI, aider, and More

Uzi is a command-line tool that uses Git worktree + tmux to run multiple AI coding agents in parallel, each with its own dependencies and development port, then uses checkpoint to merge results to the main branch with one command.


One agent slowly modifying pages, another simultaneously refactoring the backend, and a third writing tests. Multi-threaded progress efficiency far exceeds “queuing for models”. This is how Uzi works: same repository, branch isolation, parallel execution, visual monitoring, one-click merging. The official README provides complete installation, configuration, and workflow examples, with v0.0.2 released on 2025-06-03.


High-Concurrency Experimentation: Start 3-5 agents at once, each exploring different implementations or styles, then merge the best solution. True “Isolation”: Uses Git worktree to give each agent an independent branch and directory, preventing cross-contamination. Automatic Development Environment: Each agent automatically starts a dev server with assigned ports for real-time preview. Full Management: tmux manages sessions, uzi auto automatically “confirms” tool calls, ls -w shows real-time progress and diffs. One-Click Conclusion: checkpoint rebases and commits selected agent branches back to the current branch.

Industry observation: There are also container-based solutions for isolating parallel agents; Uzi takes the worktree route, which works smoothly in monorepos too. Recent InfoQ reports have highlighted comparisons between these two approaches.


Installation and Prerequisites (3-Minute Setup)

Section titled “Installation and Prerequisites (3-Minute Setup)”

Dependencies: Git, tmux, Go, and your commonly used AI tools (like Claude, Codex, Cursor, aider, etc.).

Terminal window
# Install
go install github.com/devflowinc/uzi@latest
# Ensure GOBIN is in PATH
export PATH="$PATH:$HOME/go/bin"

Create uzi.yaml in the root directory:

devCommand: cd astrobits && yarn && yarn dev --port $PORT
portRange: 3000-3010

Key Points

  • Include dependency installation in devCommand since each agent runs in an independent worktree and needs to install its own dependencies.
  • $PORT must be left as a placeholder; Uzi will automatically assign ports.
  • Official examples are also provided for Next.js / Vite / Django setups.

Section titled “Recommended Workflow: From Task to Merge in 5 Steps”

1) Parallel Start

Terminal window
uzi prompt --agents claude:3,codex:2 "Implement a REST API for user management with authentication"

Specify multiple agents and quantities; also supports random for random naming.

2) Unattended Operation

Terminal window
uzi auto

Automatically “confirms” tool calls and continuation prompts; just let it run.

3) Monitor Progress

Terminal window
uzi ls -w

Watch mode refreshes every second, showing AGENT/MODEL/DIFF/ADDR/PROMPT etc.

4) Mid-Course Commands

Terminal window
uzi broadcast "Make sure to add input validation"
uzi run "npm test"

Broadcast additional instructions; also run the same command across all agents (with --delete to close windows after completion).

5) Select and Merge

Terminal window
uzi checkpoint funny-elephant "feat: add user management API"

Rebase the matching agent branch to the current branch and commit with message.

Developer practice articles have also demonstrated similar checkpoint/kill usage patterns for customized pruning.


Scenario A | Frontend Multi-Style Exploration

Section titled “Scenario A | Frontend Multi-Style Exploration”

Give one interface component to 3 agents: minimalist / Material / enterprise style. Each agent starts its own local port; you directly compare in multiple windows and checkpoint the best one with one click.

Scenario B | Refactoring Route Competition

Section titled “Scenario B | Refactoring Route Competition”

Should backend authentication switch libraries? Should it be layered? Run 2-3 approaches in parallel, read diffs for complexity and ports for performance perception, choose the more stable route.

One agent writes API, one writes e2e tests, another writes documentation and examples. Finally, only merge the one that “runs through everything,” kill and clean up other branches anytime.


Differences from Container Parallelization Cheat Sheet

Section titled “Differences from Container Parallelization Cheat Sheet”
  • Uzi (worktree): Light, fast, Git native, suitable for same-repo multi-experiments; tmux-friendly.
  • Container Solutions: Stronger isolation, heavier operations, suitable for extreme scenarios with cross-language/system dependencies.
  • Industry Perspective: InfoQ points out that Uzi’s worktree isolation can prevent agents from interfering with each other in monorepo scenarios.

  • Port Conflicts: Make portRange large enough and ensure ports aren’t occupied.
  • Duplicate Dependency Installation: Include npm/pip install in devCommand; each agent installs its own.
  • tmux Unfamiliarity: Recommend learning basic window/panel switching to improve visibility.
  • Cost and Noise: Parallel = more tokens; suggest starting with 2-3 agents for small tasks, then scaling up. (Empirical rule, combined with community discussions about “parallel mental load” reminders.)
  • Security and Keys: Don’t hardcode sensitive env into prompts; inject via environment variables.

Terminal window
# Install
go install github.com/devflowinc/uzi@latest
export PATH="$PATH:$HOME/go/bin"
# Configure
# uzi.yaml: devCommand + portRange
# Parallel start
uzi prompt --agents claude:2,random:2 "Build a todo app with React"
# Unattended
uzi auto
# Monitor/broadcast/batch commands
uzi ls -w
uzi broadcast "Add error handling"
uzi run "npm test"
# Merge/cleanup
uzi checkpoint agent-name "feat: ..."
uzi kill agent-name | uzi kill all

Parallelization isn’t showing off. It’s a productivity tool that lets teams “take multiple correct paths simultaneously”. Integrate Uzi into your daily workflow, start with small-scale pilots, then expand to complex projects. Once you get it working, you’ll find it hard to go back to the old rhythm of queuing for models.

Discussion Question: Which project would you first split into 3 parallel routes? Why?

VibeTree Runs Multiple AI Agents in Parallel: Claude Code, Codex, Cursor CLI, aider, and More

VibeTree = Parallel Git worktree development + persistent terminals + Claude Code one-click integration, no branch switching, no lost context, efficiency soars.


Writing features, fixing production issues, then back to major refactoring… constantly git stashing, losing context back and forth is too painful. VibeTree, this open-source desktop application, combines parallel git worktrees, persistent terminals for each branch, and deep Claude CLI integration. One project opens N “clones”, each running its own tasks, each chatting with Claude.


  • Parallel Development: One repo, multiple worktrees, simultaneous feature/hotfix progress, goodbye stash.
  • Persistent Terminal Sessions: Each worktree has its own terminal, state never lost.
  • Claude CLI Integration: Direct claude command in each terminal, use /ide to connect VS Code/Cursor, file context aligned.
  • One-Click IDE Opening: Direct access to VS Code or Cursor from VibeTree.
  • Multi-Repo Tab Management: Multiple projects in parallel, smooth interface switching.
  • Cross-Platform: macOS / Windows / Linux, installation packages provided. Current latest version v0.0.1 (Alpha).

Small reminder: The repository Issues section contains user feedback on early problems, such as Windows Defender false positives, macOS 15.6 ARM64 packages marked as corrupted, etc. You might want to check before installation.


Why Use Worktrees? Better Than Multiple Clones/Frequent Branch Switching

Section titled “Why Use Worktrees? Better Than Multiple Clones/Frequent Branch Switching”
  • One Repo, Multiple Directories: Each directory is a “working copy” of a branch, sharing .git, lightweight and non-interfering.
  • Zero-Cost Switching: Production emergency? Go directly to the hotfix working directory, feature branch unaffected.

Section titled “Option A: Download Executable Package (Recommended)”
  1. Go to Releases to download:
  • macOS: .dmg (Intel & Apple Silicon)
  • Windows: .exe
  • Linux: .AppImage or .deb

Double-click to install.

Terminal window
# Install dependencies
npm install
# Development debug
npm run dev
# Production build
npm run build
# Package application
npm run package

These scripts are already configured in the repository.

Prerequisites: Git installed; for AI capabilities, recommend installing Claude Code CLI (npm one-liner, up and running in minutes).


5 Getting Started Scenarios (Sweet Workflow)

Section titled “5 Getting Started Scenarios (Sweet Workflow)”

1) “Feature + Hotfix” Dual Track Progress

Section titled “1) “Feature + Hotfix” Dual Track Progress”
  • Create feature branch worktree, simultaneously create another hotfix worktree.
  • Each has a persistent terminal, each chats with its own Claude. No panic when production breaks.
Terminal window
# Create two working directories next to project root (example)
git worktree add ../proj-feature -b feature/checkout main
git worktree add ../proj-hotfix -b hotfix/urgent main

Principle: Worktree makes “one repository, multiple working directories” a native capability.

2) “Refactor + Validation” Parallel Run

Section titled “2) “Refactor + Validation” Parallel Run”
  • A worktree does major refactoring; B worktree maintains clean baseline for comparison/regression anytime.
  • Open claude in both terminals, let AI help you “break down tasks + write tests.”
  • In corresponding worktree terminal: claude → input /ide, instantly connect to currently open VS Code/Cursor.
  • Claude and IDE share the same project root directory, context consistent, communication more accurate.

4) Multi-Repo Parallel, Centralized Control

Section titled “4) Multi-Repo Parallel, Centralized Control”
  • VibeTree’s Tab interface opens multiple repositories simultaneously, smooth switching without confusion.
  • Dark/light theme follows system, manual switching also available.
  • claude ready to use in terminal; for personalized appearance, status bar, etc., use /config to adjust.

Terminal window
# ① Install VibeTree (or build from source)
# ② Prepare two working directories (feature & hotfix)
git worktree add ../app-feature -b feature/payflow main
git worktree add ../app-hotfix -b hotfix/checkout main
# ③ Open VibeTree: open a terminal in each worktree
# ④ Type claude in terminal; if IDE connection needed, type /ide
  • Now you can: write new features in feature; reproduce and fix production issues in hotfix.
  • Two spaces don’t interfere, two Claudes online simultaneously.

Roadmap and Known Issues (Transparent Expectations)

Section titled “Roadmap and Known Issues (Transparent Expectations)”
  • Roadmap: Will support Claude completion/input-required system notifications, mobile access to Claude Code, etc.
  • Alpha Status: Please follow Issues section discussions on Windows false positives, macOS ARM64 package “corruption” prompts, privacy documentation supplements, first-start guidance, etc.

  • Independent Developers/Small Teams: Multiple diverse requirements, must progress in parallel.
  • AIGC Workflow Players: Want to truly embed Claude into branches and terminals.
  • Operations and Emergency Response: When production alerts, switch to hotfix working directory, zero switching cost.

VibeTree isn’t rebuilding an IDE; it’s an OS-level tool that makes “parallel + AI” practical. Combining the underlying advantages of “one repository, multiple workspaces” with Claude’s upper-level intelligence into a replicable daily rhythm. You’ll be surprised: every day without branch switching is more focused.

What do you think is VibeTree’s most compelling feature? Let’s chat in the comments.

Claude Code Companion: One-Click Pool Switching, Third-Party Model Integration, and Observable Logging

For those who constantly work with Claude Code, here’s a more stable and transparent “control center.”


Coding with Claude Code is great, but unstable upstream endpoints, cumbersome switching, and inaccessible logs can be frustrating. Claude Code Companion packages all this into a local API proxy: drag-and-drop sorting for priority-based pool switching, automatic failover on exceptions, plus a visual management console and complete request/response logs. Even beginners can get up and running in 10 minutes.


Supports multi-endpoint priority retry + failover. When one pool fails, it automatically switches to the next, and restores the primary when recovered. You’ll barely notice the disruption.

Built-in /admin management console lets you add/edit/delete endpoints, view real-time logs, and configure routing rules. Troubleshooting changes from “guessing” to “seeing.”

Native Anthropic support, plus OpenAI-compatible entry points for services like OpenRouter, Volcano [Huoshan] Qianwen [Qianwen], Moonshot K2, GLM—just configure the default model name.

One environment variable to disable non-essential reporting/telemetry—a crucial feature for enterprises or privacy-conscious individuals.


  • Multi-endpoint load balancing + failover
  • Upstream response format validation (reconnects on non-compliance)
  • OpenAI-compatible model integration
  • Intelligent fault detection/recovery
  • Tag-based routing (by path, header, content)
  • Request logging + web management (/admin)

All features are documented in the official README.


Go to Releases and select your platform (Win/Linux/macOS Intel/ARM), then extract. Single-file execution, no external dependencies.

Double-click or run from command line—a default config.yaml will be generated in the directory.

Visit http://localhost:8080/admin in your browser. In the Endpoints page, add upstream endpoints (URL, authentication, type: Anthropic / OpenAI-compatible). Drag and drop to adjust priorities—takes effect immediately.

In your Claude Code runtime environment, set:

Terminal window
# Essential: Route requests to local proxy
export ANTHROPIC_BASE_URL=http://localhost:8080
# Required but arbitrary: just needs to be non-empty
export ANTHROPIC_AUTH_TOKEN=dummy-token
# Recommended: Extend client timeout to avoid frontend disconnection from upstream timeouts
export API_TIMEOUT_MS=600000
# Recommended: Disable non-essential traffic (telemetry/error reporting/bug commands/auto-updates)
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

Note: Variables like ANTHROPIC_AUTH_TOKEN/CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC are documented in official docs or have equivalent configurations; BASE_URL routing for LLM gateways is also a standard practice provided officially.

Additional note: If you’re connecting to OpenAI-compatible gateways (like LiteLLM/OpenRouter), the official recommendation is the unified gateway address approach: export ANTHROPIC_BASE_URL=https://<your-gateway> (then configure token/default model).


Add multiple pools/upstreams in common → backup priority order via drag-and-drop sorting. Failed endpoints are automatically blacklisted and traffic routes to the next; recovery is detected in the background and restored. No need to restart the proxy or Claude Code.

B. One-Click Third-Party Model Integration

Section titled “B. One-Click Third-Party Model Integration”
  • Services with Anthropic-format entry points (like GLM, K2): use directly as Anthropic endpoints.
  • Services with only OpenAI-compatible entry points (like OpenRouter, some domestic clouds): add as OpenAI-compatible endpoints and fill in the default model name.

This integration method is clearly documented in the README. Services like DeepSeek also provide direct Claude Code connection guides (setting ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, model name).

Dynamic routing to different endpoints based on request path, headers, or content—suitable for stability canary releases, cost routing, or scenario specialization.

View real-time request/response logs in /admin, locate 4xx/5xx errors, timeout points, and format anomalies; supports endpoint blacklisting/recovery for observation.


Advanced: Using It as an “Enterprise LLM Gateway” Outpost

Section titled “Advanced: Using It as an “Enterprise LLM Gateway” Outpost”
  • Working with LiteLLM/Self-built Gateways: Official documentation provides LLM Gateway solutions for unified authentication, usage tracking, cost control, auditing, and model routing. Claude Code connects via ANTHROPIC_BASE_URL.
  • More Granular Privacy/Telemetry Controls: CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 for one-shot control, or use DISABLE_TELEMETRY, DISABLE_ERROR_REPORTING, DISABLE_BUG_COMMAND, DISABLE_AUTOUPDATER variables for precise control.

Q1: Claude Code not using the proxy? Check if ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN are set in the same shell; project-level settings.json can also inject unified env settings.

Q2: Third-party models returning 400/format errors? OpenAI-compatible endpoints must select “OpenAI-compatible” type and correctly set the default model name; the companion validates responses for Anthropic protocol compliance and triggers reconnection on non-compliance.

Q3: Can I use the built-in timeout controls? Yes. Increase API_TIMEOUT_MS to avoid frontend timeout causing false failure detection; Bash/MCP also have their respective timeout variables.


  • Before using third-party gateways/pools, confirm service compliance, terms allow usage, and data won’t be misused.
  • Claude Code officially provides data usage options and non-essential traffic disabling—strongly recommended to enable.

Claude Code Companion’s positioning is clear: be your local “stable control center + transparent router”. Starting today, graphically manage endpoint management, model switching, and troubleshooting, making AI programming truly worry-free.

What other “automation features” do you think should be added? For example, cost-priority/speed-priority one-click switching? See you in the comments!


Appendix: One-Click Configuration Examples

Section titled “Appendix: One-Click Configuration Examples”

macOS/Linux:

Terminal window
export ANTHROPIC_BASE_URL=http://localhost:8080
export ANTHROPIC_AUTH_TOKEN=dummy-token
export API_TIMEOUT_MS=600000
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
claude

Windows PowerShell:

Terminal window
$env:ANTHROPIC_BASE_URL="http://localhost:8080"
$env:ANTHROPIC_AUTH_TOKEN="dummy-token"
$env:API_TIMEOUT_MS="600000"
$env:CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"
claude

To integrate with gateways (like LiteLLM/OpenRouter), simply change ANTHROPIC_BASE_URL to the gateway address.

Claude Code Quietly Opened a '1M Context Window': /model sonnet[1m]

Claude Code Quietly Opened a “1M Context Window”: /model sonnet[1m]

Section titled “Claude Code Quietly Opened a “1M Context Window”: /model sonnet[1m]”

People online have reported that some Claude Code Max (20x) users can now use /model sonnet[1m] to switch to Sonnet 4’s 1M context. Anthropic has also officially confirmed that Sonnet 4’s 1,000,000 token long context is in public testing, but it’s primarily available on API / Bedrock first, with desktop and Claude Code gradually rolling out—some users may already be in “gray testing.”


1M context means you can stuff an entire medium-sized codebase, dozens of technical documents, or a stack of contracts in for analysis all at once, with less chunking and back-and-forth. Official description: roughly 75,000 lines of code/dozens of research papers consumed in one go, 5x more than before. Currently marked as Public Beta (API, Amazon Bedrock available, Vertex “coming soon”).

Community testing is also increasing: media, blogs, Hacker News, and Reddit are all discussing it.


Who Can Use It Now? Can “Max 20x” Really Access It?

Section titled “Who Can Use It Now? Can “Max 20x” Really Access It?”
  • Official Confirmation: Sonnet 4’s 1M window is live on API as Beta, requiring beta header (context-1m-2025-08-07); Amazon Bedrock has integrated it; Vertex “coming soon.”
  • Subscription Side: Claude Max plan combines Claude App and Claude Code, advertised as “up to 20x” usage quota. This is what everyone calls “Max 20x.”
  • Community Feedback: Some users report that Max 20x subscription can already switch to 1M, but others get errors; likely gradual rollout or regional/account whitelist differences. Don’t rush, try first.

Summary: API has official confirmation; Claude Code/desktop is gradually scaling up. You may have been “quietly enabled” or still in the queue.


Three Steps to Try: Switch to 1M in Claude Code

Section titled “Three Steps to Try: Switch to 1M in Claude Code”

Step 0: Update to Latest Claude Code

Terminal window
npm i -g @anthropic-ai/claude-code

Or

Terminal window
claude update

Refer to official Quickstart/CLI documentation.

Step 1: Execute in Session

> /model sonnet[1m]
⎿ Set model to sonnet[1m] (claude-sonnet-4-20250514[1m])

This is one of the valid options for built-in slash commands (community issue error logs directly list sonnet[1m]).

Step 2: Send Any Message Trigger an actual request to see if it succeeds. If it errors, don’t blame yourself—your account might not be up yet.

Step 3: Check Current Model/Status

/status

Use this to view account and system status, confirm if switched to 1M.

Advanced: Use CLI directly with model

Terminal window
claude --model claude-sonnet-4-20250514

But 1M mode usually requires server-side switches/whitelisting or corresponding beta capabilities, not guaranteed just by specifying.


Usage Recommendations: Getting Real Value from 1M

Section titled “Usage Recommendations: Getting Real Value from 1M”

1) Whole-Repository Understanding & Refactoring Navigation Bundle README, architecture diagrams, core modules, key tests and feed them in for system-level mapping and refactoring plans. Media testing shows cross-file reasoning is more stable with long windows.

2) Large Document Batch Reviews Feed multiple technical specs/compliance documents/contracts at once for comparison and risk point lists, then have it provide change recommendations and trackable tasks.

3) Codebase-Change Impact Reviews Pull recent N PRs + dependency graphs, have it assess regression risks, generate test checklists, and supplement security/performance checks.

Practical tip: Long window ≠ omnipotent. Both official and developers remind: The larger the context, the more you need clear positioning and instructions, or it’s easy to “eat a lot but digest slowly.”


Cost and Performance: Don’t Let “1M” Empty Your Wallet

Section titled “Cost and Performance: Don’t Let “1M” Empty Your Wallet”
  • API Pricing: Over 200K input tokens are charged at long context rates; 1M in Beta is open to some organizations/quotas.
  • Claude Code Subscription: While not explicitly charged per token, larger contexts consume more quota/are slower. Recommend using /compact and CLAUDE.md for summaries and instruction constraints.

  • “Set successfully but errors on first message”: Common when account not enabled or regional rollout. Confirm you have Max (20x), try multiple times or different time slots.
  • “Command not recognized / invalid option”: Upgrade to latest version, check /model available list; community logs show sonnet[1m] already appears in selectable options.
  • API side won’t connect: Remember to add beta header: context-1m-2025-08-07.

Want to make a joke, post a screenshot in the group pretending “1T context is now supported.” Don’t take it seriously, just for laughs.


One is update and try /model sonnet[1m]—you might already be enabled. Two is practice “long context usage habits”: clear goals, segment focus, regular /compact. When official full rollout happens, you’ll run faster.

  • How much improvement do you think 1M brings to real project delivery?
  • Do you prefer “consume everything at once” or “split—align—merge” workflows?
  • Have you gray-tested 1M yet? Feel free to comment with a /status screenshot (mind your privacy).

claude-code-proxy: Run OpenAI/Gemini Models with Claude Code

“Translate” Claude Code requests to OpenAI or Gemini (or direct connect to Anthropic), zero code changes, one-command integration, supports streaming and automatic model prefix matching.


Many developers want to use Claude Code’s workflow while leveraging OpenAI/Gemini’s model ecosystem and pricing structure. Switching SDKs, changing call formats, managing permissions and logging—lots of pitfalls.

This is where claude-code-proxy comes in: It allows Anthropic protocol clients (like Claude Code) to seamlessly connect to OpenAI/Gemini, or continue with Anthropic, while converting responses back to Anthropic format with complete frontend transparency.


  • Three backends with one-click switching: Set PREFERRED_PROVIDER to openai / google / anthropic. Don’t want mapping? Choose anthropic for direct connection mode.

  • Automatic model prefix handling: Automatically adds openai/, gemini/ prefixes to OpenAI/Gemini models, preventing typos.

  • Smart Haiku/Sonnet mapping: haiku → SMALL_MODEL, sonnet → BIG_MODEL; defaults to mapping to gpt-4.1(-mini) or gemini-2.5-pro / 2.0-flash.

  • Full LiteLLM backbone: Unified gateway, routing/fallback, usage tracking, budget limits, logging, and plugin extensions.

  • Complete streaming/non-streaming compatibility: Transparent to Claude clients.


Goal: Start a proxy on local port 8082 that Claude Code can point to directly.

1) Clone and install dependencies (using uv for speed)

Terminal window
git clone https://github.com/1rgs/claude-code-proxy.git
cd claude-code-proxy
# Install uv (one-time setup)
curl -LsSf https://astral.sh/uv/install.sh | sh

uv handles dependency resolution/installation based on pyproject.toml efficiently.

2) Configure environment variables

Terminal window
cp .env.example .env
# Edit .env and fill in your API keys, preferred backend, and models

Key items:

  • OPENAI_API_KEY, GEMINI_API_KEY, (optional) ANTHROPIC_API_KEY
  • PREFERRED_PROVIDER=openai|google|anthropic
  • BIG_MODEL / SMALL_MODEL (for Sonnet/Haiku mapping)

See README for details.

Gemini API Key can be created and configured as an environment variable with one click in Google AI Studio.

3) Start the service

Terminal window
uv run uvicorn server:app --host 0.0.0.0 --port 8082 --reload

--reload is suitable for development.


Install Claude Code:

Terminal window
npm install -g @anthropic-ai/claude-code

Official recommendation: avoid using sudo; see documentation for permission issues.

Point to proxy and launch:

Terminal window
ANTHROPIC_BASE_URL=http://localhost:8082 claude

After this, Claude Code’s Haiku/Sonnet will be mapped to OpenAI/Gemini or direct Anthropic connection according to your .env configuration.


Three Common Mapping Templates (Ready to Copy)

Section titled “Three Common Mapping Templates (Ready to Copy)”

A. Default to OpenAI (Simple and Reliable)

Terminal window
PREFERRED_PROVIDER=openai
OPENAI_API_KEY=sk-...
# Optional: BIG_MODEL/SMALL_MODEL
BIG_MODEL=gpt-4.1
SMALL_MODEL=gpt-4.1-mini

Haiku/Sonnet → openai/SMALL_MODEL / openai/BIG_MODEL.

B. Prefer Gemini (Cost-Friendly/Fast Response)

Terminal window
PREFERRED_PROVIDER=google
GEMINI_API_KEY=...
OPENAI_API_KEY=sk-... # As fallback
BIG_MODEL=gemini-2.5-pro-preview-03-25
SMALL_MODEL=gemini-2.0-flash

Haiku/Sonnet → corresponding gemini/ prefix; fallback to OpenAI when not in allowlist.

C. “Anthropic Transparent Proxy” Only

Terminal window
PREFERRED_PROVIDER=anthropic
ANTHROPIC_API_KEY=sk-ant-...
# Ignore BIG/SMALL, pass through to Anthropic

Benefits: Retain logging/middleware/unified entry point while avoiding mapping.


Why It’s Stable: LiteLLM Gateway Capabilities

Section titled “Why It’s Stable: LiteLLM Gateway Capabilities”
  • Unified interface for 100+ models (OpenAI, Anthropic, Google, etc.).
  • Supports routing/fallback, load balancing, budget limits, and usage tracking.
  • Customizable logging, alerts, plugins for compliance and auditing.

  1. Team Gateway: Consolidate LLM traffic from Claude Code, scripts, and backend services through this proxy for centralized cost control and auditing.

  2. Cost/Performance A/B Testing: One-click switching between OpenAI and Gemini to see which offers better cost optimization or inference accuracy.

  3. Direct Anthropic + Enhanced Governance: Preserve real models and responses while reusing proxy’s logging and limit modules.

  4. Local Development: Run port 8082 on development machine, Claude Code connects directly, zero project changes.

  5. Multi-Model Fallback: Automatic fallback when OpenAI fails, ensuring uninterrupted development (via LiteLLM routing/fallback).


  • Model Name Prefixes: Let the proxy automatically add prefixes to avoid mistakes like writing gpt-4o as gemini/gpt-4o.
  • Permissions and Keys: Gemini keys need to be requested from Google AI Studio; environment variables must be visible at runtime.
  • NPM Permissions: If Claude Code installation fails with permission errors, follow official guidance—don’t force sudo.
  • Port Conflicts: If 8082 is occupied, change --port.
  • Production Deployment: Recommend adding reverse proxy and authentication (like Nginx + Basic Auth), and enabling LiteLLM’s budgets/rate limiting/logging.

  • uv run uvicorn ... successfully listens on 8082.

  • npm i -g @anthropic-ai/claude-code installs without errors, claude doctor passes self-check.

  • Run:

    Terminal window
    ANTHROPIC_BASE_URL=http://localhost:8082 claude

    Initiate a simple conversation and observe proxy logs to confirm target model is hit.


claude-code-proxy lets you combine Claude Code’s productivity with OpenAI/Gemini’s cost-effectiveness and ecosystem together. Start the proxy today, switch models with one click, and immediately boost efficiency.

CodeGPT Brings Claude Code to VSCode, JetBrains, and Android Studio

Install the CodeGPT extension to run Claude Code directly inside VSCode and JetBrains: see visual plans, pause anytime, and edit tasks on the fly. Course‑correct mid‑run and move faster. Android Studio and the JetBrains family are supported similarly.


Still “chatting blind” with Claude Code in the terminal? There’s a smoother way: bring Claude Code into the editor UI.

With a UI you can see the plan tree, insert tasks, and undo changes. For complex tasks you don’t have to wait for the final output—correct course midway. This feels much closer to real pair programming.


  • Fewer detours: a visual plan reveals drift so you can pull it back quickly.
  • Intuitive controls: pause/continue/edit/add tasks with buttons. VSCode’s ecosystem already supports this style of UI.
  • Stay in your editor: code, Git, and tests side‑by‑side. CodeGPT focuses on multi‑model workflows and whole‑repo understanding.

Note: Anthropic also provides a VSCode extension and IDE integrations, but the core remains a terminal‑launched workflow; adding a UI enhances the experience.


  1. Open the marketplace and install “CodeGPT: Chat & AI Agents”.

  1. Sign in to your CodeGPT account (VSCode will open a browser confirm).

  2. In CodeGPT, choose Anthropic as the provider and connect your key/account per the prompts.

  1. Open the CodeGPT panel in the sidebar, select a Claude model, and enable the conversation with planning.

Tip: VSCode Marketplace (official): CodeGPT.

JetBrains (IntelliJ / PyCharm / Android Studio, etc.)

Section titled “JetBrains (IntelliJ / PyCharm / Android Studio, etc.)”
  • Install “CodeGPT: Chat & AI Agents” from the plugin marketplace, log in, and select Anthropic.

What does “controllable planning” look like?

Section titled “What does “controllable planning” look like?”

In the VSCode sidebar conversation panel you’ll see:

  • Plan/Thinking mode entry points (plan first, then execute; raise thinking depth when needed).
  • Pause/continue controls for long flows.
  • Editable task list with insertable subtasks.
  • Checkpoints and restore, so missteps are reversible.

These patterns are proven in UI extensions for Claude Code in VSCode (e.g., “Claude Code Chat” demos plan/thinking/history/restore). CodeGPT has announced support for running and controlling Claude Code planning flows inside VSCode.


  • Prompt: “Find and fix the root cause behind the latest error logs. Propose a plan first, then change code with minimal blast radius, and include self‑test steps.”
  • After you see the plan, delete unnecessary subtasks and run.
  • Add: “Generate a diff preview before applying changes.” (easier reviews)

Planning‑driven workflows have proven effective for many developers.

  • Ask for a refactor plan and a regression checklist, then apply in batches.
  • Insert a new task mid‑run: “Add a minimal unit‑test set for modified modules.”
  • If it drifts, pause immediately, edit the task tree, then resume.
  • Prompt: “Generate a minimal, runnable demo for stack X. List steps and directory changes, then create files incrementally with explanations.”
  • Add a task for Dockerfile/CI.
  • Finally, use checkpoints to compare and roll back between alternatives.

  • Plan first: have it produce a plan without touching code; execute only after you confirm.
  • Small steps: for each change, ask it to output a diff and commit message to keep rollbacks easy.
  • File context: use @filename or “Send selected file to chat” to raise accuracy.
  • Model choice: pick Sonnet/Opus for large projects or deep reasoning; smaller models for lightweight Q&A. CodeGPT can route across multiple providers.

Capability / ModeCodeGPT + VSCode UIAnthropic Official VSCode ExtensionPure Terminal CLI
Visual plans / pause/editYes (UI panel)Basic IDE/terminal integrationNo UI (text only)
Multi‑model + knowledgeYes (multi‑provider, KG)Anthropic models onlyAnthropic models
Learning curveLow (market install)Low (extension + CLI)Medium (CLI)
JetBrains supportYes (official plugin)IDE integration availableYes (terminal)
Best forTeams that edit plansFans of official + terminal flowsKeyboard/automation

Sources: CodeGPT VSCode/JetBrains plugin pages; Anthropic IDE integration and VSCode extension pages; community UI extensions showing plan/thinking/checkpoint controls.


  • Authorization: connect your Anthropic account/key as prompted by the extension.
  • Privacy: CodeGPT states SOC2 Type II; no training on your code; privacy mode available.
  • Billing: Claude Code usage bills to your Anthropic account; confirm quotas and team limits first.

  • VSCode: CodeGPT: Chat & AI Agents (marketplace)
  • JetBrains: CodeGPT: Chat & AI Agents (plugin)
  • Anthropic docs: Claude Code IDE integrations / overview

Also noted publicly: CodeGPT supports running Claude Code and controlling the planning flow directly inside VSCode—this post reflects that UI experience.


Once Claude Code lives in your editor, you’re no longer “waiting to see what it does.” It’s like guiding a junior teammate: pause anytime, edit anytime, add tasks anytime. This is what great human‑AI collaboration looks like.

Where would you plug this into your team’s pipeline? What do you think?

Subscribe to Claude on iOS at Nigeria Pricing: Step‑by‑Step Guide

Recently, many folks asked: “Claude Code is amazing, but I don’t have an overseas card, or the price feels high. Any easy, cheaper route?”
Yes. This is a practical, step‑by‑step guide to switch your Apple ID to the Nigeria region and top up with a gift card to subscribe to Claude at a lower price.

Get your phone and a little patience — follow along.


In one word: price.

App Store pricing differs by country/region. Nigeria’s in‑app prices for Claude are significantly lower than US and many other regions. With a region switch plus gift card top‑up, it’s very cost‑effective.

Prices converted at an example rate of 1 USD ≈ 7.25 RMB:

PlanOfficial (USD)US iOS (USD)Nigeria iOS (NGN)Nigeria ≈ (USD)Nigeria ≈ (RMB)vs US iOS Savingsvs Official Savings
Pro$20$20₦14,900$9.68¥70.2$10.32 (-51.6%)$10.32 (-51.6%)
Max (5x)$100$124.99₦100,000$64.94¥471.8$60.05 (-48.0%)$35.06 (-35.1%)
Max (20x)$200$249.99₦200,000$129.87¥942.6$120.12 (-48.0%)$70.13 (-35.1%)

Notes:

  • Pro: $9.68 × 7.25 ≈ ¥70.2
  • Max (5x): $64.94 × 7.25 ≈ ¥471.8
  • Max (20x): $129.87 × 7.25 ≈ ¥942.6

Actual rates fluctuate; check the store display on your date of purchase.


  • An iPhone or iPad.
  • A spare Apple ID (ideally newly registered; don’t disturb your main account to avoid affecting existing subscriptions/library).
  • Nigeria‑region Apple Gift Card (buy from a reliable seller).
  • An email and phone number from a Claude‑supported region (required for Claude registration/verification).

  1. Open Settings → tap your profile.
  2. Go to Media & PurchasesView Account.
  3. Tap Country/Region → choose Nigeria.
  4. Enter an address (e.g., a common Lagos address); set payment method to None.
  5. After success, your Apple ID store is now Nigeria.

Apple may require zero balance, no blocking subscriptions, and leaving Family Sharing before switching. Follow on‑screen prompts.


  1. Obtain the Nigeria App Store gift card code you purchased.
  2. Open App Store → avatar → Redeem Gift Card or Code.
  3. Enter the code → confirm → check balance credited to your Apple Account.

This is effectively your Nigeria store spending balance.


  1. Go to claude.ai or the app and register.
  2. Use an email from a supported region.
  3. If SMS verification fails, use a phone number from a supported region (temporary numbers often fail fraud checks).
  4. After verification, you can sign in.

  1. In the Nigeria App Store, search “Claude” and install.
  2. Sign in with your Claude account.
  3. Open the subscription screen and choose a plan.
  4. Pay with your gift‑card balance via Apple IAP.

Done 🎉 — you’re now on the discounted Nigeria pricing.


  • Use a spare Apple ID: avoid disrupting your main account’s existing subscriptions/apps.
  • Buy gift cards from reputable sellers: avoid invalid/blocked cards.
  • Cross‑region always has policy and risk‑control considerations; Apple may change rules, taxes, or exchange handling.
  • Availability varies by region; if the app doesn’t appear or connect reliably, you may need a stable network/VPN.

Despite many steps on paper, the flow is quick: in about 10 minutes you can set it up — and save real money.
After subscribing, Claude becomes a powerful helper for coding, writing, summarizing, and ideation.

Give it a try and see how much you save each month.

Subscribe to Claude on iOS: Region Switch, Gift Cards, and In‑App Purchase Guide

Goal: Successfully subscribe to Claude (Pro/Max) via the App Store on iPhone/iPad, with support for renewals and upgrades.
Who: Users in a Claude‑supported region who prefer Apple in‑app purchases.


Introduction | Why “Subscribe via Apple”

Section titled “Introduction | Why “Subscribe via Apple””
  • Peace of mind: manage plans and cancellations in one place with Apple billing.
  • Safety: pay with Gift Cards/Apple Account balance without exposing your card number.
  • Sync: native iOS app with data unified with the web version.

1) Register a Claude account (overseas email + supported‑region phone number)

Section titled “1) Register a Claude account (overseas email + supported‑region phone number)”
  • Open claude.ai, register and sign in with your email. You will then be asked to verify your phone.
  • You must use a phone number from a Claude‑supported region; the official policy explicitly requires “a supported‑region phone number” to log in. (Avoid temporary numbers — they trigger fraud controls.)

Tip: Gmail/Outlook work fine. If the phone number was previously bound to another account, contact support to un‑bind the old number before re‑binding.


2) Switch your Apple ID country/region to a Claude‑supported region (e.g., US/Canada)

Section titled “2) Switch your Apple ID country/region to a Claude‑supported region (e.g., US/Canada)”
  • Go to Settings → your name → Media & Purchases → View Account → Country/Region and follow the flow.

  • Ensure these prerequisites before switching:

    • Zero remaining balance;
    • Cancel subscriptions that block region change and wait for the billing period to end;
    • Prepare a payment method valid in the new region (Apple Account balance/Gift Card works).
  • If you are in Family Sharing, you may be unable to switch; leave the family group first.

Check accepted payment methods for the new region: see Apple’s official list (most regions accept Apple Account balance/Gift Cards).


3) Buy an Apple Gift Card for that region (commonly the US)

Section titled “3) Buy an Apple Gift Card for that region (commonly the US)”
  • Gift Cards are strictly region‑locked: redeemable only in the country/region of purchase; cross‑region redemption is not supported.
  • Don’t buy the wrong card type: an Apple Store (retail) gift card cannot be redeemed in the App Store; buy an Apple Gift Card / App Store & iTunes card.
  • Double‑check denomination/region/card type match your Apple ID exactly; prioritize authorized channels.

  • Open App Store → avatar → Redeem Gift Card or Code → enter/scan the 16‑digit code. After redemption, your Apple Account balance will show.

Balance notes: certain subscriptions/contexts have exceptions for balance usage; local rules prevail (most in‑app purchases can be charged to balance).


5) Download the Claude app and subscribe in‑app

Section titled “5) Download the Claude app and subscribe in‑app”
  • Search “Claude by Anthropic” in the App Store and install.

  • Open the app, sign in with your Claude account, choose a plan at the subscription screen, and pay via Apple IAP.

  • US pricing (subject to the store display):

    • Claude Pro monthly $20
    • Claude Pro yearly $214.99
    • Claude Max 5x monthly $124.99
    • Claude Max 20x monthly $249.99
      (Taxes/prices vary by country.)

StepKey PointCommon Pitfall
Register ClaudeSupported region + phone verificationTemp/non‑supported numbers rejected; multiple binds require un‑bind
Apple ID switchZero balance, cancel subs, payment readyFamily Sharing blocks; leftover balance below one item’s price
Buy Gift CardExact region and card typeBuying an Apple Store (retail) card for App Store; wrong region
RedeemApp Store → avatar → Redeem…16‑digit code mis‑typed/damaged; “redeem in another store” message
SubscribeIn‑app IAP, prefer balanceIn a few regions, balance limits on some subs — follow local rules

(Official references: supported regions/phone requirements; region‑switch prerequisites; Gift Card region locking; redemption steps; payment methods and pricing.)


  • Follow terms: Claude is available only to users in officially supported countries/regions; registration/login must comply with location and phone requirements.
  • No cross‑region Gift Card use: cards from the wrong region/type cannot be redeemed; Apple does not transfer balances across regions.
  • Region‑switch prerequisites: outstanding balance, active subscriptions, and Family Sharing can block switching. Follow Apple’s official flow.

Q: I’m stuck with leftover balance when switching regions — what now?
A: Purchase digital items to zero out exactly; if the balance is below one item’s price, contact Apple Support.

Q: Can I pay for Claude with balance?
A: In most regions, in‑app purchases support Apple Account balance; a few regions/subscriptions have exceptions — follow local terms.

Q: Is the app available in my chosen store?
A: The Claude iOS app is available in supported regions’ App Stores, under Claude by Anthropic.


Closing | Make Claude Your “Pocket Workbench”

Section titled “Closing | Make Claude Your “Pocket Workbench””

By now you’ve completed: supported‑region account → Apple region switch → Gift Card top‑up → in‑app subscription.
Next, turn Claude into your on‑the‑go copilot — writing, translation, notes, and image understanding all in one.

What do you think?

  • Which region will you set your Apple ID to, and why?
  • If you’ve tried Pro/Max, how does it feel in real use?

Claude Code `/context` Visualizes Context Window, Token Usage, MCP Calls, and Memory Files

TL;DR: /context renders a visual snapshot of your current session’s context window, token usage, MCP tool traces, and loaded memory files (CLAUDE.md), so you can “trim, control, and detect leaks” with confidence. This feature appeared around Claude Code v1.0.86 based on community feedback and testing.


Ever had a conversation suddenly get “auto-compacted,” scattering key info into folded chunks?

/context is like a “body-fat scale” for your conversation. It lays out what’s actually in the context, which parts are overweight, and why compaction triggered. It also highlights which MCP tools were used and which CLAUDE.md memory files were pulled in—perfect for targeted optimization.


  • One-glance context view: See which segments are in the window, how many tokens each consumes, and how close you are to the limit. (Community notes: for a 200k window, auto-compaction often triggers around ~80% usage.)
  • Find the “heavy hitters”: Shows MCP usage and large files read via tools so you can slim down.
  • Verify memory: Surfaces loaded CLAUDE.md / CLAUDE.local.md so you can avoid overstuffed memory.
  • Cost awareness: Cross-check /context with a status bar or third-party tools (like ccusage) to spot silent drains. (Rough guidance seen: average daily cost around $6; 90% of users under $12.)

Note: /context metrics may differ slightly from other sources (auto-compaction prompts, ccusage, custom status bars). Treat it as a diagnostic view.


1) Mid/late-stage “health check” for long threads

Section titled “1) Mid/late-stage “health check” for long threads”

During a long-running task, run /context to see which passages consume the most tokens. Pair with /compact focus: {this week’s goals and deltas} for targeted slimming, so old detours don’t keep riding along. (Slash commands including /compact are officially supported workflows.)

If /context shows an oversized CLAUDE.md in your home or project, split wisely: keep standards and conventions in the project-level CLAUDE.md; put temporary preferences in CLAUDE.local.md; and reference large docs via excerpts instead of dumping them all in at once.

Use /context to see which MCP calls hit search/DB/external APIs. Identify the most token-expensive call chains, then apply allowlists or rate limits. MCP is a first-class integration in Claude, ideal for connecting external tools at scale.

4) “Travel light” before a sprint or release

Section titled “4) “Travel light” before a sprint or release”

Before merging or releasing, run /context to confirm there’s no irrelevant conversation history or bloated memory inflating the window. Reducing clutter lowers the chance of auto-compaction and improves response stability. The “~80% triggers compaction” heuristic is a helpful reference.

Mount ccusage in your status bar to watch current session/today/5‑hour block consumption. If you see a spike, open /context and line things up.


Capability/contextAuto-compaction promptsccusage (status bar)Custom status bar
GranularityFine: segments/MCP/memory visibleCoarse: threshold onlyFine: real-time cost/tokensDepends on script
Memory visibilityYes: shows CLAUDE.md sourcesNoNoPossible
MCP visibilityYesNoNoPossible
AccuracyEarly versions may vary slightlyAccurateAccurate (billing/logs-based)Varies
Best forDiagnosis/optimizationEveryday useCost-sensitive workflowsPower users

Note: Accuracy notes reflect official/community docs and issue threads; /context continues to evolve.


  • Inspect context: Type /context and review large chunks and sources (MCP/memory/history).
  • Targeted slimming: /compact focus: "current iteration goals and blockers" to focus, then compact.
  • Memory governance: Put conventions in project CLAUDE.md; keep ad-hoc prefs in CLAUDE.local.md; split large docs by reference.
  • MCP allowlist: Allow only trusted tools to run automatically; require interactive approval when needed; add rate limits if necessary.
  • Cost linkage: Install ccusage and compare observations with /context regularly.

  • Numbers won’t always match: /context is still maturing and may differ from a status bar or auto-compaction prompts; treat billing/logs as the source of truth.
  • Don’t treat memory as a dumping ground: Memory files are auto-read; large ones will consume context. Control granularity.
  • MCP isn’t a free lunch: Each external lookup/read may incur extra tokens. Use allowlists and rate limits.

/context is your developer “context checkup sheet.” To use Claude Code more stably, efficiently, and cost‑effectively, make the invisible visible. From today, build three habits: check /context often, use /compact intentionally, and keep memory lean. You’ll see steadier responses, better cost control, and smoother collaboration.

What views would you add to /context? Do you have a “status bar + /context” combo you like? Share your setup and tips.

Seamless Switch: Claude Code × DeepSeek v3.1

DeepSeek v3.1 adds Anthropic API compatibility. Point Claude Code’s BASE_URL and auth to DeepSeek and keep using Claude Code’s workflows and tools, while swapping the underlying model to DeepSeek for a similar experience at friendlier cost.


Many folks ask: can we keep the full Claude Code experience — REPL, /config, permission sandbox, hooks, status line — but swap the underlying model to a more cost-effective one?

Now the answer is yes. DeepSeek v3.1 announced Anthropic-compatible APIs, making the integration straightforward.


  • Seamless Claude Code integration: keep the CLI, project permissions, MCP/tooling; only change env vars and model names.
  • Friendlier pricing: DeepSeek Chat (v3.1) lists input $0.27 per 1M tokens (cache miss) and output $1.10 per 1M tokens. Compared to Claude Sonnet 3.7/4 at $3 / $15, input is about 1/11 and output about 1/13.6 — real savings.
  • 128K context (v3.1) plus strict function calling (Beta). Great for code agents and tool orchestration.

Note: Anthropic is also pushing Sonnet 4 with 1M context (billed at higher tiers). That upper limit is an advantage DeepSeek doesn’t yet match — choose by workload.


Terminal window
npm install -g @anthropic-ai/claude-code

(After install, run claude doctor to self-check versions and dependencies.)

2) Configure environment variables (official pattern)

Section titled “2) Configure environment variables (official pattern)”
Terminal window
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=${YOUR_API_KEY}
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat

Notes:

  • ANTHROPIC_BASE_URL points to DeepSeek’s Anthropic-compatible endpoint.
  • ANTHROPIC_AUTH_TOKEN is used as Authorization: Bearer ....
  • ANTHROPIC_MODEL and ANTHROPIC_SMALL_FAST_MODEL select DeepSeek’s model in Claude Code.
Terminal window
cd my-project
claude

You’ll still see the Claude Code interactive workflow, but requests go to DeepSeek.

Want to persist settings? Put the above vars into ~/.claude/settings.json under env. Project/global both supported for easy team rollout.


A. Use settings.json to pin model and limits

Section titled “A. Use settings.json to pin model and limits”
{
"model": "deepseek-chat",
"env": {
"ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
"ANTHROPIC_AUTH_TOKEN": "sk-***",
"ANTHROPIC_MODEL": "deepseek-chat",
"ANTHROPIC_SMALL_FAST_MODEL": "deepseek-chat",
"CLAUDE_CODE_MAX_OUTPUT_TOKENS": "4096"
}
}

This avoids repeated exports when starting new projects and helps teams standardize quickly.

You can point ANTHROPIC_BASE_URL to an internal LLM Gateway/LiteLLM to enable routing, circuit-breaking, cost dashboards, and quotas. Official docs support ANTHROPIC_BASE_URL and apiKeyHelper style configurations.

  • Unify small-task model: set ANTHROPIC_SMALL_FAST_MODEL to DeepSeek (used for scan/retrieval/light reasoning by default).
  • Cap output: tune CLAUDE_CODE_MAX_OUTPUT_TOKENS to prevent long outputs from consuming too many tokens.
  • Function calling: v3.1 supports strict function calling (Beta) to drive structured toolchains and reduce detours/token waste.

DeepSeek’s Anthropic compatibility layer covers common fields like messages, tools, streaming, temperature, top_p, etc. It also notes unsupported content types (e.g., image, document, search_result, and some MCP/container fields). For those needs, either switch back to Claude for that task or adjust prompts/flows.

Also remember sensitive file isolation. Use Claude Code’s permissions.deny to hide .env, secrets/**, etc., preventing model reads.


ItemDeepSeek Chat (v3.1)Claude Sonnet 3.7/4
Input (per 1M tokens)$0.27 (cache miss)$3
Output (per 1M tokens)$1.10$15

Bottom line: input about 1/11, output about 1/13.6. If you’re doing code refactors, retrieval, unit-test generation, the savings show up fast.


  • Individuals/SMBs: budget-sensitive but want engineering efficiency and stable tooling.
  • Agent/automation projects: frequent calls, predictable responses; prioritize cost control.
  • Education/experiments: keep the same Claude Code UX while quickly evaluating different model strategies.

Q: The REPL still shows “Claude” — is DeepSeek actually running?

A: Yes. The shell is Claude Code, the engine is DeepSeek. Requests go to DeepSeek per your ANTHROPIC_BASE_URL and auth settings.

Q: Do I need to change SDKs?

A: Not if you use the Claude Code interactive workflow — just set env vars. If you call from code, you can use the Anthropic SDK and set BASE_URL to DeepSeek’s Anthropic endpoint.

Q: Any differences in the compatibility layer?

A: Yes. DeepSeek lists ignored/unsupported headers and message types. Tools are mostly supported, but image/document message types aren’t yet — plan accordingly.


Saved cost is real runway. Keep Claude Code’s productivity, swap the expensive model for DeepSeek where it fits. Make the switch today; your month-end bill will thank you.

Want a ready-to-use ~/.claude/settings.json template and a simple cost calculator? I can draft one for your project.


Terminal window
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=sk-deepseek-***
export ANTHROPIC_MODEL=deepseek-chat
export ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat
claude

From DeepSeek’s official guide and Claude Code env docs.

Python (Anthropic SDK pointing to DeepSeek)

Section titled “Python (Anthropic SDK pointing to DeepSeek)”
Terminal window
pip install anthropic
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_API_KEY=sk-deepseek-***
import anthropic
client = anthropic.Anthropic()
msg = client.messages.create(
model="deepseek-chat",
max_tokens=800,
messages=[{"role":"user","content":"Hi, from DeepSeek via Anthropic SDK!"}]
)
print(msg.content)

Turn Claude Code into a Productivity Dashboard with ccstatusline

ccstatusline turns Claude Code’s bottom status bar into a “visual cockpit” — model info, Git branch, tokens, context usage, session time, and a 5‑hour block progress bar at a glance. You can even embed your own command outputs.


For daily coding, two worries dominate: runaway cost and context blow‑ups. Claude Code now supports a custom statusline — a perfect home for a live dashboard.

ccstatusline is built for exactly this. It shows model, tokens, and context % out of the box, ships with Powerline themes, and most importantly, includes a Block Timer to visualize the 5‑hour window.


1) See your 5‑hour block — with a progress bar

Section titled “1) See your 5‑hour block — with a progress bar”
  • Auto‑detects conversation block boundaries and elapsed time;
  • Two progress‑bar styles (32/16 chars);
  • Raw value mode supported.

Rhythm matters: you’ll know when to pause and when to reset.

  • Arrow separators, customizable caps, multiple built‑in themes;
  • 16/256/TrueColor all supported.

Looks great, packs information, blends with your terminal theme.

  • npx/bunx to open an interactive config UI;
  • Up to 3 independent lines; WYSIWYG;
  • Settings saved to ~/.config/ccstatusline/settings.json.
  • If it prints, it fits;
  • Plug in ccusage to show real‑time cost/usage.

Example: npx -y ccusage@latest statusline — docs include best‑practice flags.

Model, Git branch/changes, input/output/cache tokens, context length and %, session clock, version, output styles, smart width truncation — the “signal among noise” for focused coding.


Terminal window
# Configure via npm
npx ccstatusline@latest
# Or bun (faster)
bunx ccstatusline@latest

In the TUI, add/reorder items, tweak colors, separators, and padding, then write into Claude Code settings.

Tip for VSCode terminal colors: set terminal.integrated.minimumContrastRatio to 1.

Model / Tokens Total / Context % (available) / Session Clock / Block Timer (progress bar) / Git Branch + Changes. For width, “Full width minus 40” helps avoid over‑compression.


Advanced: visualize “cost” and “rhythm”

Section titled “Advanced: visualize “cost” and “rhythm””

A. Plug in ccusage — know where money goes

Section titled “A. Plug in ccusage — know where money goes”
  1. Add a Custom Command in ccstatusline: npx -y ccusage@latest statusline
  2. Set timeout to 5000 (first install may take time).
  3. Check “preserve colors”.

You’ll see session cost, daily total, current block cost and remaining time, and live burn rate.

Heads‑up: with older ccusage or slow networks, you may hit OOM/repeat calls — set timeouts and upgrade.

B. Custom commands: surface “out‑of‑context” signals

Section titled “B. Custom commands: surface “out‑of‑context” signals”
  • Current dir: pwd | xargs basename
  • Node version: node -v
  • Current commit: git rev-parse --short HEAD
  • Time: date +%H:%M
  • Weather: curl -s wttr.in?format="%t"

Make sure commands are fast — slow ones get killed by the refresher.

  • Line 1: model, tokens, context;
  • Line 2: git, dir, time;
  • Line 3: block progress, cost (ccusage).

Layered info + smart truncation keeps noise at bay.


  • Cost control: pair with ccusage to watch live burn and block cost — great for personal and team reviews;
  • Long‑haul tasks: Block Timer supports natural focus/break pacing;
  • Team consistency: built‑in themes unify look and metrics for pair/review;
  • Demos/streams: the statusline narrates context and cost in real time;
  • Cross‑platform: runs on Bun/Node; Windows improvements are tracked via docs and feedback.

  • Commands must be fast: slow custom commands will be terminated; they also slow refresh;
  • VSCode color oddities: set min contrast to 1 or use an external terminal;
  • Width wrapping: use “Full width minus 40” or switch layouts by context thresholds;
  • ccusage performance: set timeout, upgrade, or run standalone for health checks.

Don’t bury critical coding signals inside commands, files, or memory. Spread them on the statusline. See clearly, spend wisely, code steadily.

Fire up the “visual cockpit” and give Claude Code real instrumentation. npx ccstatusline@latest — ship it today.

The Everyday AI Stack: 7 Tools for Max Productivity at Minimal Cost (Aug 2025)

After a month of swapping models back and forth, I settled on a daily setup that balances performance × price × speed. The goal is simple: practical, reusable, and cost‑controlled. Here’s the exact stack and workflows I use daily — and recommend to teams and family.


🚀 1) Work code: Claude Code 200u (heavy‑duty development)

Section titled “🚀 1) Work code: Claude Code 200u (heavy‑duty development)”

Highlights

  • Run Claude directly in the terminal for transparent, controllable development; Pro/Max subscriptions connect web/desktop/mobile and the CLI.
  • With Opus 4 / Sonnet 4, it sustains long‑chain tasks and complex projects with strong iterative coding ability.
  • Anthropic notes subscription perks like more usage, daily‑tool connections, and extended reasoning — a good fit for engineering workflows.

Practical notes

  • Some vendors have introduced weekly throttling/anti‑abuse rules. For heavy use, stage long‑running tasks and save snapshots to avoid disruption.

Best for

  • Multi‑task monorepos, cross‑service refactors, and generate‑debug‑regress cycles.
  • Engineers who prefer to “orchestrate AI from the terminal.”

Quick start tip

  • Plan with Sonnet 4; execute mostly with Sonnet 4/Opus 4 as guardrails. Split work into 30–60‑minute sprints and persist artifacts between stages.

🌐 2) Communication & translation: claude‑sonnet‑4‑20250514 (pin the snapshot)

Section titled “🌐 2) Communication & translation: claude‑sonnet‑4‑20250514 (pin the snapshot)”

Why a precise version? Anthropic recommends pinning to a specific snapshot (e.g., claude-sonnet-4-20250514) in production to avoid behavior drift from alias updates.

Best for

  • Bilingual email, PR statements, and localized product copy.
  • Meeting notes that need consistent tone and logic.

Quick start tip

  • Provide audience profile + comms goal first. Then ask for three rewrites (formal/friendly/minimal) and extract a glossary to unify terminology.

📖 3) Reading translation: OpenAI GPT‑4.1 nano (lighter is faster)

Section titled “📖 3) Reading translation: OpenAI GPT‑4.1 nano (lighter is faster)”

Highlights

  • Very low latency and cost — ideal for short texts and light processing.
  • 1M‑token context is great for bulk organization and side‑by‑side translation.

Best for

  • PDF summaries, paragraph‑level aligned translations, annotated notes.
  • Rule‑based rewrites: titles, abstracts, key‑point cards.

Quick start tip

  • Let nano handle structured extraction + light polishing. Hand heavy rewrites and stylistic lifts to higher‑tier models — cheaper and more stable overall.

🎙️ 4) Speech‑to‑text: ElevenLabs Scribe v1

Section titled “🎙️ 4) Speech‑to‑text: ElevenLabs Scribe v1”

Highlights

  • 99 languages, word‑level timestamps, speaker diarization, and audio event tags (laughter/applause).
  • Positioned as high‑accuracy ASR, robust for noisy environments and multi‑speaker meetings.

Best for

  • Remote meetings, interviews, podcasts, call recordings.
  • Legal retention and training materials.

Quick start tip

  • Use API with model_id=scribe_v1. For long audio, chunk while preserving timestamps to align playback later.

🧽 5) Post‑edit transcripts: OpenAI GPT‑4.1 mini

Section titled “🧽 5) Post‑edit transcripts: OpenAI GPT‑4.1 mini”

Why mini?

  • Compared with nano, mini follows instructions and reorganizes text more reliably. It’s stronger for formatting key points, summaries, and action lists; pricing/docs favor lightweight reasoning.

Best for

  • “ASR → structured minutes → todo list/email drafts.”
  • Extract decisions/risks/owners from Scribe output.

🔎 6) Web/research: Gemini × Claude × Grok — use all three

Section titled “🔎 6) Web/research: Gemini × Claude × Grok — use all three”

Each shines at something

  • Gemini: Google Search Grounding + Deep Research for web‑grounded, auditable sources and systematic investigations.
  • Claude: subscription includes Research; great for read‑ask‑write across projects/docs.
  • Grok 4: built‑in real‑time search and native tool calls — strong on timeliness and X‑ecosystem tracking.

My flow

  • Gemini to map the space and list key sources;
  • Claude to read long docs and produce a structured draft;
  • Grok to watch hot updates and last‑24‑hour changes.

👪 7) Family everyday: ChatGPT Plus ($20; Memory is the moat)

Section titled “👪 7) Family everyday: ChatGPT Plus ($20; Memory is the moat)”

Why Plus for family

  • Affordable and sufficient models; official guidance is clear.
  • Memory can be toggled/cleared/managed — gets more helpful over time.
  • Recent updates improved cross‑chat memory and personalization, ideal for family schedules, homework help, and reminders.

Best for

  • Family lists, school notices, travel templates.
  • “Kid‑voice rewrites” and “elder‑friendly instructions.”

Before → During → After meetings

  1. Before: Gemini Deep Research for a 30‑minute pre‑read with sources.
  2. During: live transcription via Scribe v1.
  3. After: GPT‑4.1 mini for minutes and action items; Claude Sonnet‑4‑20250514 for external emails.

Dev → Test → Release

  1. Claude Code 200u for refactors and long‑chain tasks;
  2. Use nano to batch format and extract labels from stage artifacts;
  3. Sonnet 4 to finalize release notes and changelogs.

  • Usage limits: heavy development should watch for throttling — stage runs and snapshot often to avoid interruptions.
  • Version pinning: pin API models to snapshots to prevent alias drift and unstable results.
  • Privacy & Memory: when family uses ChatGPT Memory, know how to disable/clear it anytime in settings.

  • Code long‑runs: Claude Code (Opus/Sonnet 4 combo).
  • Precise external comms: Sonnet‑4‑20250514 snapshot.
  • Lightweight reading/batch work: GPT‑4.1 nano.
  • Meeting ASR: Scribe v1.
  • Minutes & email: GPT‑4.1 mini + Sonnet 4.
  • Three‑way web research: Gemini Grounding / Claude Research / Grok 4.
  • Family assistant: ChatGPT Plus (Memory on).

A good AI stack should swap “time anxiety” for “steady delivery.” This setup is what my team and I actually use. Trim it to your needs; start with one end‑to‑end workflow, then expand.

Which one is your strongest single pick? Want a follow‑up with “cost‑saver tips + ready‑to‑use config files”?

Claude Code, Cursor, GitHub Copilot Subscriptions Too Expensive? Maybe It's Time to Learn from TikTok

Claude Code, Cursor, Copilot Subscriptions Too Expensive? Maybe It’s Time to Learn from TikTok

Section titled “Claude Code, Cursor, Copilot Subscriptions Too Expensive? Maybe It’s Time to Learn from TikTok”

How Mainstream AI Programming Assistants Make Money

Section titled “How Mainstream AI Programming Assistants Make Money”

Current popular AI programming tools like GitHub Copilot, Cursor, and Claude Code primarily follow subscription-based business models with monthly fees. These tools are also experiencing rapid user growth:

  • GitHub Copilot (Microsoft GitHub): Individual subscription around $10/month, providing code auto-completion and chat features. Since launching in 2021, it has gained massive popularity, with over 20 million users having tried Copilot by 2025 (all-time users). Paid users exceed 1.8 million (as of early 2024). Copilot is also popular in enterprise - Microsoft CEO Nadella revealed that 90% of Fortune 100 companies use Copilot. With subscription pricing, Microsoft also bundles it into more expensive enterprise packages. Leveraging the massive developer ecosystem, Copilot’s revenue growth is rapid - in 2024, Nadella said its “business scale has exceeded the entire GitHub when Microsoft acquired it in 2018.”

  • Cursor (developed by Anysphere): An AI code editor built on VS Code, using a freemium model. Individuals get free Hobby version (with two-week Pro trial) and paid Pro version ($20/month); power users have $200/month Ultra tier with higher usage limits and priority new features. This pricing is quite affordable, leading to explosive Cursor user growth. Early 2025 reports suggested Cursor daily active users exceeded 1 million, with annualized recurring revenue around $200 million; months later its ARR climbed to $500 million - stunning growth showing many users willing to pay. However, Cursor team faces escalating costs as users grow. Reports indicate many AI programming companies have near-zero or negative gross margins due to high model inference costs, with “all code generation products having either zero or negative profit margins.” Despite Anysphere reaching $500 million ARR by June 2024, becoming one of the fastest SaaS companies to break $100M ARR, high compute costs pressure profits, forcing pricing strategy adjustments to shift some excess usage costs to heavy users.

  • Claude Code (launched by Anthropic): Anthropic integrates its advanced Claude model into terminals and IDEs, creating this AI programming assistant. Claude Code doesn’t charge separately but is included in Claude.ai subscription plans: individual Pro plan $20/month (about $17/month annually), subscription includes Claude Code access. Higher-tier Max plans at $100/month (5x usage) or $200/month (20x usage) provide larger context windows and stronger models (Claude Opus 4.1). In other words, Claude Code follows a “subscribe for AI service, get tools included” approach, using valuable coding assistants to attract developers to subscribe to AI services. Anthropic also offers usage-based API pricing for enterprises. Claude Code emphasizes deep code understanding and cross-file editing, receiving good feedback from professional development teams. However, compared to Copilot and Cursor, Claude Code user scale data is less public, possibly because it mainly targets paid user groups, using refined operations rather than broad-net strategies.

Overall, these AI programming assistants primarily use subscription monetization, ranging from tens to hundreds of dollars monthly, targeting the market where programmers pay for efficiency. Free users either cannot access features (Copilot discontinued free trials) or face significant limitations (Cursor free version has usage limits). While this business model is direct, it means no payment equals no full functionality. Could there be alternative approaches using common internet advertising/entertainment monetization methods to create new revenue streams for these AI tools? Before discussing this idea, let’s examine how short videos, live streaming, gaming and other sectors “make money.”

Short Videos, Live Streaming, Advertising: Internet’s Golden Money-Making Playbook

Section titled “Short Videos, Live Streaming, Advertising: Internet’s Golden Money-Making Playbook”

In the internet industry, user attention is hard currency. Short video platforms, live streaming, advertising distribution, and mobile games all achieve commercial value by capturing user attention for extended periods:

  • Short Videos (Douyin/TikTok): Through precise algorithmic recommendations, users scroll videos endlessly, enabling interspersed feed advertising for efficient monetization. Taking Douyin as example, by 2024 its monthly active users reached 1 billion (China only). Users spend average 110 minutes daily on Douyin, nearly equivalent to watching a full movie! With long user engagement, ads get ample display opportunities. Douyin’s advertising revenue soars, projected to reach $30 billion in 2024 (including splash screens, feeds, stickers, etc.). Additionally, Douyin integrates live commerce and e-commerce traffic, expanding monetization scenarios - statistics show over 40% of daily active users watch or participate in Douyin live commerce. Short video platforms dramatically increase user stickiness through algorithms + content, exchanging massive user time for high advertising revenue.

  • Video Websites (YouTube): As traditional long-video platform, YouTube’s main revenue also comes from ad insertion and creator revenue sharing. YouTube has 2.49 billion monthly active users globally, with 2023 advertising revenue reaching $31 billion. Average users spend nearly 49 minutes daily watching YouTube. The platform profits through pre-roll, mid-roll, and recommended page ads, then shares revenue with content creators. This model validates the logic that “as long as users watch long enough, ads will sell.” Recently YouTube introduced Shorts and live streaming, further increasing user engagement and enriching ad inventory. Video platforms use massive content to retain users, then monetize through advertising - a mature and efficient business logic.

  • Live Streaming Platforms (Twitch, etc.): Live streaming stimulates user enthusiasm through real-time interaction, beyond advertising, also driving user donations and subscriptions. Amazon’s gaming live streaming platform Twitch achieved 20.8 billion hours of total viewing time in 2024, with about 240 million monthly active users globally and 35 million daily active users. Half of Twitch’s revenue comes from advertising (ads inserted in streamer broadcasts, platform shares with streamers), half from user subscriptions and gift donations. Twitch generated approximately $1.8 billion revenue in 2024. Though smaller user base than short videos, dedicated viewers willing to pay for favorite streamers means higher ARPU (Average Revenue Per User). Live streaming monetization centers on strong community atmosphere: real-time chat, emotional connections between fans and streamers all increase user payment willingness. This model proves that even without short video-scale mass appeal, strong stickiness and deep interaction can generate considerable revenue.

  • Mobile Games and Interactive Games: Many games, especially free mobile games, monetize through in-app purchases and advertising. On one hand, few paying players (“whales”) contribute purchase revenue, on the other hand, many non-paying players become advertising monetization targets by watching ads for in-game rewards. Some casual mobile games design “watch 30-second ad for coins” mechanics, or insert ads during level loading. This “exchange waiting time for revenue” approach is common. Statistics show 2024 global mobile gaming market revenue exceeded $111 billion, with advertising revenue comprising significant portion. Google even launched App Open Ads specifically for displaying ads during app loading screens, letting developers monetize user waiting seconds. Gaming industry deeply understands this: monetize fragmented time, not wasting any moment users stay on screen.

In summary, whether short videos or live streaming, the underlying business logic is using excellent content or interactive experiences to keep users on platforms as long as possible, then monetizing user attention through advertising or value-added services. Can this logic transfer to AI programming assistants? Could we envision a model where programmers watch customized short videos or interactive content during AI coding breaks, using entertainment advertising revenue to replace part of subscription fees? This sounds far-fetched, but let’s boldly brainstorm.

Can You Watch Videos While AI Writes Code? Feasibility Analysis

Section titled “Can You Watch Videos While AI Writes Code? Feasibility Analysis”

Imagine a typical scenario: programmer Zhang uses AI assistant in VS Code to generate code, sometimes waiting several seconds for model results. These few seconds of downtime currently mean staring at “Thinking…” cursor. What if Zhang could see interesting content during these gaps, utilizing fragmented time?

Technically, this isn’t impossible. AI programming tools typically exist as plugins or standalone applications - Copilot is IDE plugin, Cursor is VS Code-based standalone editor, Claude Code runs in terminal/IDE. These tool interfaces could easily reserve small windows to push content during AI request processing. Similar to loading tips on web pages or mobile game loading screens, except here it could be personalized video/information feeds.

The key is what content to push that’s both engaging and non-disruptive to work? Learning from short video and content recommendation experience, ideal approach is precise interest matching. AI assistants already understand user code and context - with user authorization, they might guess user interests based on coding themes. For example:

  • When users write Python code for unit testing, small window pushes “3 Tips for Improving Test Efficiency” short video, 30 seconds perfectly matching current task.
  • During debugging downtime, push programmer humor short videos or funny memes, making users smile and relieving frustration.
  • Based on user preferences (like frequently reading frontend articles), recommend related tech influencer live clips or new product launch segments, keeping users updated on industry trends.

Of course, implementing smart recommendations requires building content recommendation algorithms. Could reference TikTok’s multi-layer machine learning models, rapidly iterating recommendations based on user behavior. AI programming assistants already call large models to understand code context, could combine with user-set interest tags for content filtering. Let users check preferred content types in settings: “Tech tutorials / Tech news / Comedy / Gaming streams / …” then assistant selects pushes accordingly.

More importantly, controlling frequency and format. Programmers need focus for coding, can’t let popup content overshadow main functionality. Ideal design is embedded: editor sidebar shows small muted video window, or output area displays news feed cards. After AI response generation, content auto-collapses without interrupting user flow. Google’s App Open Ads emphasizes choosing natural timing (like loading screens) for ad display, avoiding core experience disruption. Similarly, AI assistant content pushes should only occur during natural pauses like model computation or code compilation, with one-click close option.

For monetization, these pushed contents could include advertising elements. For example, pushed short videos feature vendor-promoted new developer tools (presented as content marketing), or live streams embed product links (users might need technical books/courses). Bing Chat already experiments with embedding ad links in chat answers, Microsoft states will share ad revenue with content providers. This shows integrating advertising into AI responses/interfaces is viable commercial attempt. In coding assistant scenarios, advertising could be more subtle and relevant: when users use free AI assistant for frontend code, small window recommends “more efficient frontend debugging tool” (actually advertising partnership promotion), users click if interested or skip if not, experience similar to seeing ads on TikTok.

Any Precedents? Industry Exploration and Comparisons

Section titled “Any Precedents? Industry Exploration and Comparisons”

This “AI programming + entertainment advertising” model currently lacks direct mature cases, but related explorations exist:

  • Developer Community Advertising Attempts: Traditional programming Q&A sites like Stack Overflow historically monetized through page ads and enterprise recruitment ads. Though not AI tools, this shows developers aren’t completely ad-averse, provided ad content is highly relevant and doesn’t interfere with getting answers. Similarly, if AI assistants push developer-related news or products (like cloud service promotions, tech conference live previews), users might welcome them, even finding them educational.

  • AI Chat and Advertising Integration: Microsoft’s new Bing (Bing Chat) already inserts sponsored links in GPT-4 powered chat answers, sometimes including product ad cards for shopping queries. This essentially embeds search advertising directly into conversations. Though coding assistant scenarios differ from search, Bing’s practice proves large model responses and commercial advertising can coexist. Key is transparent labeling and relevance, letting users clearly identify ads while ensuring ads truly match their needs.

  • AI Tool Extension Windows: Some programming tools already show signs of news pushing. For example, JetBrains IDE shows “Tip of the Day” on startup, VS Code welcome page often has recommended articles or update announcements. These are embedded information content within tool interfaces, just not yet commercialized. If these windows became customizable content streams, it would be technically natural.

  • Free Models and User Scale: Currently some AI programming tools take free routes to attract users, then seek other monetization. For example, open-source Codeium is free for individuals, using data to improve models then charging enterprises later. But no clear “free + advertising” cases exist. On one hand, developer user base is much smaller than consumer apps, whether advertising monetization can cover high compute costs is questionable. On the other hand, programmer users demand higher product purity, rashly adding ads might cause backlash. So most startups choose direct subscription fees or enterprise payment rather than prioritizing advertising models.

  • Domestic Developments: Worth noting, domestic tech giants are also advancing AI coding assistants, like Alibaba’s “Tongyi Lingma.” According to Alibaba’s 2025 financial report, Tongyi Lingma (coding assistant) achieved strong revenue growth. However, it mainly targets enterprise customers, representing successful B2B paid model, different from our discussed C2C entertainment advertising approach. Tencent states AI technology has contributed to its performance advertising and gaming businesses, indirectly proving AI and advertising integration potential.

Overall, currently no direct products fusing programming assistants with entertainment content monetization, but from search chat to app loading ads to various successful freemium models, many borrowable elements exist. If some team dares break conventions, launching such “code writing + video watching” crossover product, it might truly open new blue ocean.

Future Outlook: AI Programming Assistant Entertainment Path

Section titled “Future Outlook: AI Programming Assistant Entertainment Path”

Imagine future development scenarios: you sit at computer writing code, AI assistant helps debug. During compilation breaks, it thoughtfully pushes “Today’s Programming Joke” short video for entertainment, or pops up AR real-scene hacker mini-game for few seconds of brain relaxation. This might sound absurd, but isn’t impossible. As new generation developers gradually adapt to multitasking and fragmented information streams, this work-entertainment intertwined mode might be more popular than imagined.

Commercially, “AI programming + entertainment advertising” model could bring win-win:

  • For individual developers, lower entry barriers - maybe no expensive subscription fees needed, just free access to powerful code AI tools, only tolerating some well-timed content pushes as exchange. Same logic already accepted in mobile apps (many apps offer “watch ads to unlock premium features” options).

  • For platform vendors, diversified revenue sources, shared compute costs. Current AI programming assistant profitability challenges largely stem from each additional user means additional compute costs, unlike traditional software where expansion doesn’t increase marginal costs. Introducing advertising monetization means even non-paying users generate revenue through ad viewing, helping subsidize model inference costs, alleviating “more users, more losses” predicament. This could make business models more sustainable.

  • For advertisers, new channel reaching programmer demographics. Programmers as high-consumption, high-decision-influence group have always been desired but hard-to-reach audience for many B2B and tech product advertisers. If programming scenario native ad placements exist, promoting cloud services, development tools, IT books/courses and other vertical products could have higher conversion rates than random TikTok advertising. Especially combined with AI understanding of user code intent, ad precision would improve significantly (provided privacy permissions and careful balance, otherwise easily causing backlash).

Of course, this path faces considerable challenges. First, not affecting user experience is biggest test. Programmers need long-term focused thinking, frequent entertainment content popups would interrupt flow. If content quality is poor or irrelevant, users would rather close assistant than be disturbed. Therefore content recommendations must be sufficiently personalized and valuable, ideally inspiring work (like recommending related technical solution video tutorials, more acceptable than pure commercial ads). Simultaneously need complete user control, like setting “focus mode” with no content pushes, or allowing paid ad removal (like many apps’ “remove ads pro version”).

Second, scale effects are problematic. Global developer numbers are large but far from entertainment app user bases. To rely on advertising monetization, per-user ad revenue must cover model inference costs, requiring improvements in both ad effectiveness and compute cost reduction. One possibility is introducing gamification elements to stimulate usage time: like coding challenge mini-games where users playing trains models while exposing more ads, killing multiple birds. But these ideas need practical validation.

Finally, from trends perspective, AI tool entertainment and advertising is indeed an anticipatable direction. Just as adding games to office software sounds ridiculous, but Microsoft Teams already has built-in casual games for colleague meeting breaks, proving traditional productivity tools are experimenting with entertainment elements. Similarly, future AI programming assistants needn’t be cold tools, could become interesting, cute, even “comedian” personalities. When post-90s, post-00s become development mainstream, they might prefer work becoming as “meme-filled” as browsing Weibo. Once user mindsets shift, business model innovation has fertile ground.

Summary and Brainstorming: AI programming assistants moving from paid to free + advertising represents interesting crossover fusion imagination. It represents future possibility: work and entertainment no longer clearly separated, but naturally fused through AI bridges. Maybe in few years, when you use AI to write code, it’ll play programming tutorial live replays when you’re debugging stuck, let you play pixel-style coder jumping games during project builds. Then coding experience becomes both efficient and fun, coding no longer boring, bugs gain some playful seasoning.

Of course, this remains bold speculation. But these imaginative ideas point toward possible next directions. After all, in AI era world, imagination is often the best productivity. Let’s wait and see - maybe the next industry-disrupting business model will emerge from such brainstorming.

Use Zelda Sound Effects to Make Claude Code Call You Back

Vibe Coding’s biggest pain point: waiting for AI to finish. Start a long task, go do something else, come back and it’s been done for ages. Sound notifications become essential.

Today’s little toy maxes out both efficiency and fun: zelda-claude-code. It stuffs Zelda notification sounds into Claude Code - task completion, combos, achievement unlocks all get that satisfying “ding” sound.


zelda-claude-code is an npm package that adds sound effects and achievement system to Claude Code:

  • Success/failure, combos, achievements, session start/end… all have different sound effects;
  • Built-in stats dashboard: success rate, streaks, highest combo, most-used tools;
  • Use @zelda series commands directly in Claude Code to adjust volume, toggle notifications, view data.

Additionally, Claude Code natively supports Hooks/notifications, triggering your custom scripts at moments like “response finished/needs your action/tool completed” - this is the underlying capability that makes these sound effect plugins work seamlessly.


  • Works out of the box: One-line install, restart Claude Code and it works. @zelda help shows the menu.
  • Non-intrusive but present: Success sound, error sound, no need to watch screen. Busy with other things but still get “called back”. (Claude Code also supports terminal bell/notification channels, this is the official path.)
  • Playability: Combos (3/5/10/20/50…), achievements (perfect zero errors, etc.), turning boring waiting into “monster hunting”.
  • Cross-platform: macOS / Linux / Windows / WSL all supported, with platform-specific player detection/troubleshooting suggestions.
  • Privacy-friendly: Data stored locally (~/.zelda/), doesn’t go online.

First ensure Claude Code is installed (Node.js 18+) → Then install Zelda plugin.

Terminal window
# 1) Install Claude Code (official)
npm install -g @anthropic-ai/claude-code
# 2) Install Zelda sound effects (community)
npm install -g zelda-claude-code@latest
# 3) Restart Claude Code (important)
exit
# Re-enter project directory and run
claude
# 4) View help
@zelda help

The above Zelda package is from npm, docs/source code on GitHub.

If you prefer the “pure official” approach, you can directly switch notification channel to terminal bell: claude config set --global preferredNotifChannel terminal_bell (simple “ding” sound).


  • Long rounds/deep planning: Like large repo refactoring, full-chain CI debugging - AI stops and sounds, no more “waiting by the screen”.
  • Multitasking: Writing reviews while letting Claude Code modify code; sound arrives → switch back to confirm.
  • Team streaming/pairing: Combos and achievements make collaboration more atmospheric; failure sounds remind “where something just broke”.
  • Cross-device notifications: Want to push notifications to phone/watch? Use community scripts/automation to forward Claude notifications to iPhone/Watch.

@zelda stats # View current session + historical data
@zelda achievements # View achievement progress
@zelda combo # See current combo
@zelda config volume 60 # Adjust volume (0~100)
@zelda config sounds.combo false # Turn off combo sounds
@zelda config notifications.achievements true # Enable achievement popups

All commands used directly in Claude Code.


Comparison: Three Ways to Enable “Sound Notifications”

Section titled “Comparison: Three Ways to Enable “Sound Notifications””
MethodInstall CostCapabilitySuitable ForNotes
Terminal Bell (official channel)Very LowTask completion “ding”Just want simple alertspreferredNotifChannel terminal_bell.
claude-sounds scriptLowMultiple sound effects via HookLike DIY tinkeringShell script + Hook, simple to modify.
zelda-claude-codeLowSound effects + combos + achievements + statsWant both efficiency and funnpm one-click install, command-based config.

  • Custom sounds: Put in sounds/ directory, name success.wav / error.wav / achievement.wav ... to replace.

  • Sound not playing?

    • @zelda config volume 100;
    • macOS check afplay, Linux check aplay/paplay, Windows uses PowerShell player;
    • Re-run ./demo_sounds.sh to test audio.
  • More Hook/notification possibilities: Claude Code officially supports Notification/Stop/PostToolUse and other Hooks, triggering logic at “end time”/“after tool completion”/“when confirmation needed” (like logging work hours, desktop notifications, running formatters).


  • This is a third-party community package, watch versions and security; exit and restart anytime if issues arise.
  • README reminder: Zelda is Nintendo trademark, please obtain materials legally.
  • Don’t want high-frequency interruptions? Lower volume to 30~50, keep only key events; or use official bell channel for minimal non-intrusion.

Sound notifications save looking back; fun feedback stabilizes mental flow. Make Claude Code not just faster, but more “feelable”. Install and try today - next time it sounds, you might have just finished writing good code.

Do you think this kind of “sound effects + achievements” gamification of work can improve focus? Would you use it?

Ki2API: Use Kiro's Claude Sonnet 4 Model for Free with Claude Code

Ki2API is a Dockerized, elegant OpenAI-compatible API gateway that exposes Claude Sonnet 4 as /v1/chat/completions, allowing legacy code to use the new model with minimal changes.


  • Fully compatible with OpenAI API format: Uses /v1/models, /v1/chat/completions, supports SSE streaming. Migration costs are minimal.
  • Focuses on one stable model: Built-in claude-sonnet-4-20250514, the stable version number listed in Anthropic documentation and cloud providers, eliminating the “did they change the alias again today?” headache.
  • One-command service startup: docker-compose up -d, defaults to listening on http://localhost:8989.
  • Hassle-free credentials: Container automatically reads local ~/.aws/sso/cache/kiro-auth-token.json (Windows: %USERPROFILE%\.aws\sso\cache\…) with automatic token refresh logic.

Note: Claude Sonnet 4 is the next-generation Sonnet released in May 2025, featuring stronger reasoning and more stable coding, with excellent price/performance ratio, available via API and major cloud providers.


  • Existing OpenAI SDK projects wanting to drop-in replace with Claude Sonnet 4, avoiding major interface changes.
  • Corporate intranets/single machines needing a lightweight gateway to route team calls through a standard entry point for auditing and rate limiting.
  • Multi-model evaluation/A-B testing, connecting Sonnet 4 behind “OpenAI format” for universal scaffolding.
  • Tool chains requiring streaming output (Terminal/CLI, frontend chat boxes, log monitoring), with SSE out-of-the-box.

Terminal window
docker-compose up -d
  • Default service address: http://localhost:8989
  • Default API Key: ki2api-key-2024 (for local development use).
  • Health check: GET /health
  • List models: GET /v1/models
  • Chat: POST /v1/chat/completions All endpoints and default port are documented in the project README.
Terminal window
# Environment variables
export ANTHROPIC_BASE_URL="http://localhost:8989/v1/chat/completions"
export ANTHROPIC_AUTH_TOKEN="ki2api-key-2024"

On machines logged into Kiro, the container automatically reads local token files and auto-refreshes; you can also explicitly pass KIRO_ACCESS_TOKEN/KIRO_REFRESH_TOKEN.

2) Direct Connection with OpenAI SDK (Node/JS)

Section titled “2) Direct Connection with OpenAI SDK (Node/JS)”
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "ki2api-key-2024",
baseURL: "http://localhost:8989/v1",
});
const completion = await client.chat.completions.create({
model: "claude-sonnet-4-20250514",
messages: [{ role: "user", content: "Introduce Ki2API in one sentence" }],
stream: false
});
console.log(completion.choices[0].message.content);

Streaming: Just set stream: true, frontend/Node listens to SSE for real-time rendering.

Terminal window
curl -H "Authorization: Bearer ki2api-key-2024" \
http://localhost:8989/v1/models
{"object":"list","data":[{"id":"claude-sonnet-4-20250514","object":"model","created":1755296317,"owned_by":"ki2api"},{"id":"claude-3-5-haiku-20241022","object":"model","created":1755296317,"owned_by":"ki2api"}]}
Terminal window
curl -X POST http://localhost:8989/v1/chat/completions \
-H "Authorization: Bearer ki2api-key-2024" \
-H "Content-Type: application/json" \
-d '{
"model": "claude-sonnet-4-20250514",
"messages": [{"role": "user", "content": "Hello, please introduce yourself"}],
"max_tokens": 1000
}'
Terminal window
curl -X POST http://localhost:8989/v1/chat/completions \
-H "Authorization: Bearer ki2api-key-2024" \
-H "Content-Type: application/json" \
-d '{
"model": "claude-sonnet-4-20250514",
"messages": [
{"role": "user", "content": "Write a poem about spring"}
],
"stream": true,
"max_tokens": 500
}'
data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"role":"assistant"}}]}
data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"content":"Spring Hymn\n\nTender green buds crown the willow tips,\nPeach blossoms smile, reflecting clear streams.\nSwallows return, busy carrying mud,\nButterflies dance gracefully without rest.\n\nWarm breeze gently sweeps across fields,"}}]}
data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"content":"\nGentle rain nourishes silently.\nAll things revive with vitality,\nBright spring light fills the world.\n\nChildren fly paper kites high,\nElders admire flowers in courtyards.\nA year's"}}]}
data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{"content":" plan begins in spring,\nHope seeds planted in the heart."}}]}
data: {"id":"chatcmpl-ca5987c8-c362-4f0c-b90c-1e2ee8035d77","object":"chat.completion.chunk","created":1755296346,"model":"claude-sonnet-4-20250514","system_fingerprint":"fp_ki2api_v3","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}
data: [DONE]

As shown in the README, it also supports stream: true for streaming requests.


Complementary Perspective on Similar Solutions

Section titled “Complementary Perspective on Similar Solutions”
  • Some community gateways also bridge “Claude ↔ OpenAI format”, but Ki2API focuses on single model, lightweight startup, making it ideal for rapid deployment and teaching/sharing scenarios.

Ki2API turns “switching models” into “changing baseURL + model name” - that’s it. For individuals and small teams wanting to quickly adopt Sonnet 4, it’s very friendly.

Which project are you planning to switch first? What do you think?

Station: Unified Management for Claude/Cursor Agents

Want a self‑hosted, versionable, packable agent runtime so the “mini‑agents” you build in Claude Code or Cursor can actually go live? Station was built exactly for that.


The tool called Station has been making the rounds lately. It’s not yet another “application‑level” agent platform. Instead, it’s a lightweight runtime and packaging/distribution system purpose‑built for deployable sub‑agents. In one sentence: take the “small but capable agents” you create in Claude Code or Cursor, then package them, ship to production, connect permissions, audit every run, and manage versions cleanly.


Highlights at a Glance (Built for Internal Use)

Section titled “Highlights at a Glance (Built for Internal Use)”

Why Station? Because internal automation isn’t a normal app: you need secrets, database access, CI/CD, and auditability.

  • Internal‑task first: Sub‑agents can read production databases (with proper controls), monitor infrastructure, drive CI/CD, run security scans, and handle incident response.
  • Security built‑in: Self‑hosted, secret encryption (AES), multi‑environment isolation (dev/staging/prod), and full audit trails.
  • Lightweight and pluggable: A single ~45MB binary with local SQLite out of the box; switch to PostgreSQL in production; natural GitOps (config is versionable).
  • MCP‑native: Acts directly as an MCP runtime, reusing your team‑approved MCP tools (filesystem, Slack, AWS, K8s, DB, and more).
  • Great DX: A Genkit‑powered browser playground plus stn develop for visualizing tool calls and execution flows.

What’s MCP? In short, it’s a unified protocol for letting LLMs use “controlled tools.” Claude Desktop’s official tutorial includes a quickstart and configuration examples.


The core structure is simple: One .prompt file + a set of MCP tools = a deployable sub‑agent. Environments are organized as dev/staging/prod. Tool definitions live in template.json; environment variables in variables.yml. Finally, everything can be bundled and installed elsewhere.


Installation and Integration (Up and Running in 5 Minutes)

Section titled “Installation and Integration (Up and Running in 5 Minutes)”
  1. Install & initialize
Terminal window
curl -fsSL https://raw.githubusercontent.com/cloudshipai/station/main/install.sh | bash
stn init # initialize DB and encryption
  1. Connect to Claude Desktop / Claude Code (MCP) Add this to your Claude config:
{
"mcpServers": {
"station": {
"command": "stn",
"args": ["stdio"]
}
}
}

Now tell Claude “Create a security‑audit agent,” and it will automatically equip that agent with the necessary tools (e.g., file scan + Slack).

  1. One‑click bundle & install (promote environment to prod)
Terminal window
stn template create prod-bundle --env default --name "Prod Bundle" --author "Team" --description "Prod env"
stn template bundle prod-bundle
stn template install prod-bundle.tar.gz production
stn sync production

You’ll now have a deployable package containing multiple sub‑agents + multiple MCP servers.

Want visual debugging? Run locally:

Terminal window
genkit start -- stn develop --env dev

Test inputs in the browser and watch live traces and logs.


Section titled “Recommended Use Cases (Copy‑Ready Examples Included)”

1) Security & Compliance Baselines (+ Slack alerts)

Section titled “1) Security & Compliance Baselines (+ Slack alerts)”
  • Goal: Periodically scan sensitive directories; push high‑risk findings to Slack immediately.
  • How: Create SecurityScanner.prompt; attach filesystem MCP + Slack MCP; set execution metadata and step limits in Station.
  • Trigger (inside Claude): “Run a security scan on /etc and post critical findings to #sec-alerts.”
  • Value: Automation + traceability makes audits and retrospectives easier.

2) Infra Health Checks / Cost Dashboards (AWS cost)

Section titled “2) Infra Health Checks / Cost Dashboards (AWS cost)”
  • Goal: Pull the last 7 days of AWS costs, generate a daily report, and send it via Slack.
  • How: Combine AWS cost tools + Slack; output Markdown on a schedule.
  • Value: Turn “AI + cloud cost” into a steady rhythm your team can rely on.

3) CI/CD Deployment Automation (containers/K8s)

Section titled “3) CI/CD Deployment Automation (containers/K8s)”
  • Goal: For a small release, run docker exec + kubectl apply, and write back the change‑request link.
  • How: Combine Docker MCP + Kubernetes MCP; deployments become one‑sentence operations.
  • Value: Humans speak intention; agents do the grunt work.

4) Read‑only Prod DB Checks / Slow SQL Sampling

Section titled “4) Read‑only Prod DB Checks / Slow SQL Sampling”
  • Goal: Connect to production (read‑only credentials), sample slow queries and index hits.
  • How: Combine DB MCP with custom analysis scripts.
  • Value: Inspect issues close to the source to cut down back‑and‑forth firefighting.

5) Code‑Review Bot (with internal rules)

Section titled “5) Code‑Review Bot (with internal rules)”
  • Goal: Produce review suggestions aligned with team rules (security/performance/style).
  • How: Define scoring dimensions and output format in .prompt; attach filesystem MCP to read code; emit structured suggestions.
  • Value: Productize “coding standards” for consistent enforcement.

How It Differs from App‑Style Agent Platforms

Section titled “How It Differs from App‑Style Agent Platforms”
  • Station targets tasks that “enter your intranet and require permissions and auditing.”
  • Emphasis on self‑hosting and data sovereignty.
  • The single‑binary + SQLite lightweight form makes it feel like an ops tool, not a platform.

You can also treat Station as an MCP “hub.” It can consume other MCP servers, and also expose MCP tools to others for “list agents / create agents / invoke agents.”


  • Secret management: Store keys and connection strings in Station’s encrypted vault, isolated per environment.
  • Least privilege: Equip each sub‑agent with only the MCP tools it needs — less is more.
  • GitOps: Put template.json, .prompt, and variables.yml in git; land via MR and then cut a release.
  • Audit trails: Every execution has a trace; incidents are fully reconstructable.

Station turns those “small, capable agents” from ideas discussed at your desktop into deployable, auditable, and replicable internal automation. No need to wrangle another platform — write a good .prompt, attach the right tools, and ship the bundle to production. That’s what I like most about it: simple, controlled, and easy to propagate.

What’s the very first sub‑agent your team should build? Share in the comments, or pass this along to your teammates and design your own “internal agent factory.”

A Tamagotchi in Claude Code — It Even Tells Me Not to Stay Up Late…

A slightly absurd, oddly addictive little toy. It lives in Claude Code’s status bar, breathes, pouts, and roasts your TODOs. If you code for too long it gets hungry; when debugging goes sideways it comforts you; it’ll even remind you to drink water and grab a bite.


  • It truly lives in the status bar: Breathes with your session rhythm, switches expressions, and floats “mood bubbles.” It’s not a static screenshot widget — it’s alive.

  • It understands your “cadence”: Updates are activity‑based, not wall‑clock‑based; detects whether you’ve taken a break (≥ 5 minutes). State persists in ~/.claude/pets/, so memory survives restarts.

  • Four attributes: Hunger, Energy, Cleanliness, Happiness. It warns you when values drop below thresholds. It will genuinely “beg to be fed.”

  • It talks: Comes with 200+ contextual thoughts — comments on your coding style and work habits, with occasional life wisdom.

  • Two interaction channels:

    • Slash commands: /pet-feed pizza, /pet-play ball, /pet-sleep, /pet-stats, …
    • Terminal CLI: claude-code-tamagotchi feed pizza, ... play ball, ... stats, etc.
  • Tunable personality: Plenty of env vars + prebuilt “personas” (Zen Master, Drama Queen, Debugger, Silent Companion, etc.). Make it chatty — or let it fade into the background.

  • MIT open source; recently published on npm with rapid fixes for compatibility and UX (works directly via Node.js, shows model name by default, fixes state persistence, etc.).

Background: What is Claude Code proper? It’s Anthropic’s agentic command‑line coding assistant — reads your project structure, runs toolchains, and manages git flows. Tamagotchi adds an “emotional status‑bar buddy” on top.


Option A | Global install (fastest)

Terminal window
# 1) Install
npm install -g claude-code-tamagotchi
# or
bun add -g claude-code-tamagotchi
# 2) Enable the status‑bar pet: edit ~/.claude/settings.json
{
"statusLine": {
"type": "command",
"command": "bunx claude-code-tamagotchi statusline",
"padding": 0
}
}
  • Pros: See the pet immediately in the status bar; bundled CLI commands.
  • Note: Slash commands are not included. For /pet-*, see next step.

Add Slash commands (optional)

Terminal window
git clone https://github.com/Ido-Levi/claude-code-tamagotchi.git /tmp/claude-pet && \
cp -r /tmp/claude-pet/claude-commands/* ~/.claude/commands/ && \
rm -rf /tmp/claude-pet
  • You can now use /pet-feed, /pet-play, etc. directly inside Claude Code.

Option B | Clone + auto‑configure (full features)

Terminal window
git clone https://github.com/Ido-Levi/claude-code-tamagotchi.git
cd claude-code-tamagotchi
./setup.sh
  • The script installs dependencies, configures the status bar, and drops in all /pet-* commands in one go.

Tip: The author has published the package to npm and fixed “works without Bun, directly via Node.js” compatibility; it also shows the current Claude model name by default. If you want the “minimal path,” Option A is great.


2) Where the Joy Comes From: Real “Companionship”

Section titled “2) Where the Joy Comes From: Real “Companionship””
  • It tells you not to push through at 2 a.m. — “We’ve been at this for four hours… fuel up first?” It’s kind of funny, but it can break bad late‑night loops.
  • Mood‑driven expressions: (◕ᴥ◕)(◕ᴗ◕) when happy and breathing; (-ᴥ-) asleep; (◕︵◕) needs attention. Emotion is the status‑bar UI.
  • “Personality toggles”: Go Zen by slowing decay; go high‑energy by speeding recovery; want a “code nitpicker”? Dial up the weight for coding‑related thoughts.

  1. Long debugging sessions: When you’re drowning in logs, it nudges you to move. Reduces the “fixing makes it worse” spiral.
  2. Live streams, lessons, internal demos: A breathing pet on screen instantly warms the room — interaction skyrockets.
  3. Remote team vibe: Distribute a shared persona preset; everyone’s pets “check in and banter” together — lightweight team social.
  4. Self‑management: Pair /pet-stats with small rewards (“breaks count as feeding”) to build healthier habits.
  5. Status‑bar info hub: Shows current directory, session count, and model name — you feel more in control when switching models or folders.

4) One‑Command Personality Swaps: Handy Presets

Section titled “4) One‑Command Personality Swaps: Handy Presets”
  • Zen Master (barely interrupts)

    Terminal window
    export PET_DECAY_INTERVAL=100
    export PET_HUNGER_DECAY=0.1
    export PET_ENERGY_DECAY=0.1
    export PET_CLEAN_DECAY=0.1
    export PET_CHATTINESS=quiet
  • Debugger (code‑focused)

    Terminal window
    export PET_THOUGHT_WEIGHT_CODING=70
    export PET_THOUGHT_WEIGHT_RANDOM=5
    export PET_THOUGHT_FREQUENCY=10
  • Drama Queen (expressive needs)

    Terminal window
    export PET_NEED_THRESHOLD=70
    export PET_CRITICAL_THRESHOLD=50
    export PET_CHATTINESS=chatty

All presets come from the README. Add them to ~/.zshrc / ~/.bashrc to take effect.


  • Can’t see the pet? Restart Claude Code and check statusLine in ~/.claude/settings.json.
  • Commands not working? Ensure /pet-* files exist in ~/.claude/commands/; check bun --version if you’re using Bun.
  • Uninstall? Remove ~/.claude/commands/pet-*.md, clean up ~/.claude/pets/*.json, and delete the statusLine config.

Work needs efficiency, your mind needs care. This little pet won’t write code for you, but it brings back a bit of “human warmth” to collaborating with AI. Install it and give it two days. You might start to enjoy being “seen while coding.” (As of 2025-08-15, the project has about 36⭐ and is being updated rapidly.)

Claude Code on a Budget

Trim conversations, pick the right model, lock down permissions — and your Claude Code bill can drop by half.


Many teams use Claude Code and feel “budget pain” every month. It’s not that you typed too much — it’s the invisible token sink eating the bill. The good news: you can control it, and the effect is immediate.

This guide breaks cost‑saving into three tiers: basic, intermediate, advanced. Follow them and you’ll save the bulk of your spend.


I. Where Does the Money Go? 4 “Token Sinks”

Section titled “I. Where Does the Money Go? 4 “Token Sinks””

1) Invisible context from system and memory Claude Code automatically loads the system prompt and layered CLAUDE.md memory (org/project/user). This content enters context on every turn, naturally consuming tokens.**

2) Big price gaps across models Official pricing: Sonnet 4 ≈ $3/$15 per million input/output tokens; Opus 4/4.1 ≈ $15/$75. For the same conversation, switching models means ~5× unit price.**

3) Context gets fatter as you chat Claude Code supports very large contexts (Sonnet 4 up to 1M tokens in testing). Longer chats trigger auto‑compression and repeated “setup”, making tokens fly.**

4) Background and noise spending Beyond visible replies, /cost queries, auto‑summaries, Haiku prompts, etc., also burn small amounts of tokens. Pennies add up.**

Summary: It’s not that you ask too much — it’s that “everything gets hauled on stage every time.”


  • Manual slimming beats passive compression Use /compact proactively, and add a focus directive:

    /compact Focus on code diffs and failing tests only

    Auto‑compression triggers near 95% capacity — waiting is too late.**

  • One task per thread; clear when done Start a new session for each small task; once finished, run /clear to avoid a ballooning history.**

  • Pick the right default model Use Sonnet 4 for day‑to‑day development. When you truly hit “hard/long/deep reasoning,” switch to Opus via /model. You can also use “Opus for planning + Sonnet for execution” — stronger planning, cheaper execution.**

  • Check the bill anytime In any session, run /cost to see current spend; teams can check history in the console and set workspace spend limits.**

Figure idea (illustration 2:1 | English copy) “A developer squeezing a giant chat bubble into a slim pill, while a tiny receipt shows shrinking token numbers.”


B. Intermediate: Tighten the Flow, Shrink the Bill

Section titled “B. Intermediate: Tighten the Flow, Shrink the Bill”
  • Docs‑first to prevent context blowups First have Claude produce a “TODO list / brief plan,” confirm, then execute. Iterate in Plan Mode (planning mode); confirm and switch back to execution.**

  • Put “long‑term memory” into CLAUDE.md Put standards, common commands, and project conventions into CLAUDE.md; next time it applies automatically. Use /memory to edit quickly in a chat when needed. Memory loads by layer automatically, reducing the tokens you spend “repeating yourself.”**

  • Small commits, easy to roll back Ask Claude to produce a commit message after each small chunk. If something goes wrong, roll back — fewer wrong turns means fewer tokens. (Engineering practice)

  • Team rate‑limits & flight instruments Set sane TPM (tokens per minute) based on org size to avoid costly concurrency “meltdowns.”**


C. Advanced: Hard‑Core Cost Downs (Biggest Gains)

Section titled “C. Advanced: Hard‑Core Cost Downs (Biggest Gains)”

1) Permission allow/deny lists to stop “random file reads” Use /permissions + .claude/settings.json to forbid logs, binaries, and huge directories, and allow only necessary paths. Rules support gitignore patterns.**

{
"defaultMode": "plan",
"readRules": [
"src/**",
"docs/**",
"!**/*.log",
"!**/*.bin",
"!node_modules/**",
"!dist/**",
"!coverage/**"
],
"editRules": ["src/**", "docs/**"]
}

Note: plan mode analyzes without changing files; read/write rules shrink the file surface — less scanning = fewer tokens.**

2) Be precise to “lines,” not whole files Don’t paste entire blocks. Provide file path + target line ranges + 5 key bullets to minimize irrelevant scanning. (Engineering practice)

3) Model split: let Opus handle only the “expensive parts” In /model, use Opus for plans/architecture/cross‑module dependency analysis; hand off code generation and fixes to Sonnet. This is the recommended direction from official guidance.**

4) (Team/Gateway) Use Prompt Caching For API or enterprise gateways, prompt caching saves visibly on repeated large prefixes. Official pricing offers cheaper write/hit rates for cached prompts.**


III. Ready‑to‑Use Cost‑Saving Checklist

Section titled “III. Ready‑to‑Use Cost‑Saving Checklist”
  • Default to Sonnet; switch to Opus only when needed: flip with /model.**
  • Keep Plan Mode on by default: plan first, execute after confirmation.**
  • Start every session by slimming: /compact Focus on code diffs and test failures.**
  • Close the loop with /clear: prevent ever‑growing history.**
  • Strict permissions: use /permissions and readRules/editRules to restrict directories and types.**
  • Audit anytime: /cost + console “workspace spend limit.”**
  • Write memory into CLAUDE.md: reduce repeated priming and context stuffing.**

  • Unit price spread: Opus costs about Sonnet. Concentrate “expensive thinking” in planning; use Sonnet for execution — total cost drops significantly.**
  • Size costs: auto‑loaded memory + long threads fatten context; proactive /compact and /clear shrink transfer volume directly.**
  • Less irrelevant I/O: permissions and rules act as a cost firewall, blocking large, low‑value dirs/files.**
  • Background overhead under control: knowing what “quietly spends” helps you avoid pointless refreshes and queries.**

Claude Code’s power comes from “bringing everything along.” The key to saving is to bring only what’s necessary.

Apply this checklist to your project today: start with /model, /compact, /clear, then add CLAUDE.md and permission rules. By month’s end, your bill should surprise you — in a good way.

What do you think? What other money pits have you hit? Share in the comments.

Conductor Orchestrates Multiple Claude Code Agents

Conductor: Orchestrate Multiple Claude Code Agents Together

Section titled “Conductor: Orchestrate Multiple Claude Code Agents Together”

In one sentence: Conductor lets you spin up multiple “Claude teammates” at once, each with its own isolated git worktree, so different tasks progress in parallel; you can also see who’s working, who’s stuck, and what changed — all at a glance.

For complex projects, parallel progress is the productivity unlock. The traditional approach means opening lots of terminals, manually splitting branches, hopping directories — and it’s easy to step on each other’s toes. Conductor turns that workflow into a visual control panel: with a few clicks, you can have multiple Claude Code instances working in their own isolated workspaces simultaneously. It also supports local/GitHub/any Git URL repositories, multi‑tab terminals, Slash commands, message queues, and archiving scripts — the practical stuff you actually need.

❗️Note: This article’s Conductor refers to the macOS app from conductor.build, not the Netflix/Orkes microservices workflow engine “Conductor OSS.” Don’t mix them up.


1) Visual multi‑agent parallelism: see who’s running, who’s blocked, and what changed

Section titled “1) Visual multi‑agent parallelism: see who’s running, who’s blocked, and what changed”

Each Claude Code instance works independently, while the UI shows status and diffs — a team‑like collaboration experience.

2) Real isolation: each workspace is a new git worktree

Section titled “2) Real isolation: each workspace is a new git worktree”

Not just a temp folder — it’s one worktree + branch per agent, preventing overwrites and conflicts. The official FAQ is explicit: “Yes, each workspace is a new git worktree.”

3) Works with local repos, GitHub, any Git URL

Section titled “3) Works with local repos, GitHub, any Git URL”

Recent changes added local repository support; you can also one‑click clone remote repos and work entirely on your Mac.

Changelog entries repeatedly mention fixes/improvements for terminal tabs, confirming multi‑tab terminal support is built in.

5) Slash commands built in: capture frequent actions into short commands

Section titled “5) Slash commands built in: capture frequent actions into short commands”

The official updates announce Slash commands are live, manageable in settings; they pair nicely with Claude Code’s own Slash mechanism.

The changelog mentions a message queue (process multiple messages in order) and optional archiving scripts, making it easy to turn conversations and outputs into a traceable asset.

Conductor directly uses your current Claude Code setup (API key, Pro or Max plan). No redundant configuration.


Platform: currently a macOS app; visit the website and click Download Conductor.

Prep Claude Code: install and ensure Claude Code CLI/native binary works locally (see the official installation script/docs).

First run:

  1. Open Conductor and add a repository as prompted (local path / GitHub / any Git URL).
  2. Choose the number of Claude Code agents to start and give each a task description.
  3. The app will create an independent worktree + branch for each agent and begin execution.

Getting Started: 3 Parallel Scenarios for Everyday Development

Section titled “Getting Started: 3 Parallel Scenarios for Everyday Development”

Scenario A: Fix tests while running Lint and formatting

Section titled “Scenario A: Fix tests while running Lint and formatting”
  • Agent A: fix failing unit tests and assertions
  • Agent B: run ruff/black/eslint/prettier, etc.
  • Agent C: update CI configuration in sync Each agent works on a separate worktree branch without interference; merge them one by one afterward.

Scenario B: Safe rollout + canary/rollback choreography

Section titled “Scenario B: Safe rollout + canary/rollback choreography”
  • Agent A: refactor authentication logic
  • Agent B: write rollback scripts and feature flags
  • Agent C: add SLO monitoring and alerts Turn these into Slash commands like /ship feature-x, /prepare rollback so one tap runs the whole flow.

Scenario C: Documentation and knowledge capture

Section titled “Scenario C: Documentation and knowledge capture”
  • A message queue lets you “throw tasks in to be processed in order,” then batch‑review the results
  • Use archiving scripts to package key conversations, change logs, and outputs (e.g., pre‑release dossiers) (Both features are noted in the official changelog; combine with your team’s conventions for automation.)

Workflow Suggestions (Aligned with Claude Code Best Practices)

Section titled “Workflow Suggestions (Aligned with Claude Code Best Practices)”
  • Crisp task splitting: each agent focuses on one goal (e.g., Auth refactor / new reports page / DSL parser)
  • Maintain isolation: use separate worktree branches for different tasks to avoid blocking and improve merge quality/speed.
  • Template commands: collapse common prompts into Slash commands, turning “boilerplate chatter” into “one‑line instructions.”

  1. Install Claude Code (if you haven’t).
  2. Download and open Conductor.
  3. In Conductor, add a repository (local / GitHub / Git URL).
  4. Create multiple agents and write their individual tasks.
  5. Watch logs/commands in the multi‑tab terminal; use the message queue when needed to send batched messages in order.
  6. Use Slash commands to reuse your favorite workflows.
  7. When done, use archiving scripts to package artifacts, or merge branches and ship.

  • Don’t confuse it with Conductor OSS: that’s a microservices orchestration platform (Netflix/Orkes community) — different from this Claude Code GUI.
  • Claude Code only (for now): the FAQ says, “Right now, just Claude Code. Others coming soon.” Don’t expect other models immediately.
  • Performance: parallelism consumes local resources; control agent count and use the message queue to pace execution.

Conductor = multi‑agent parallelism + worktree isolation + visual control. If you constantly juggle multiple tasks and worry about stepping on changes, this tool can instantly boost throughput and flow. Paired with Slash commands and archiving scripts, it turns “manual processes” into standardized buttons and converts “dialogue outputs” into a traceable knowledge base.

Do you think this “multi‑agent in parallel” approach fits your projects? How would you split tasks? Share your experience in the comments.

Tuning Claude Code Output Style @agent-output-style-setup

In Claude Code 1.0.80, there’s an undocumented Agent @agent-output-style-setup that can create and switch “output styles” in one go (e.g., ultra‑concise, reviewer mode, educational mode). It turns rambling into a summary and long text into diff + key points. This Agent was surfaced by community testing and public posts.


  • The official Styles capability lets you customize tone, structure, and detail level — matching real situations like “be formal for reports, be crisp for bug fixes.”
  • Claude Code supports configuration, slash Agents, and project‑level settings — ideal for making “style” a repeatable, versionable workflow.

The combo is: generate styles via the hidden Agent → switch with a slash Agent → control the pace by scenario.


Community posts and issues indicate that after running @agent-output-style-setup, the terminal Agent guides you through preference prompts and generates several switchable styles (such as Concise, Educational, Code Reviewer, Rapid Prototyping). Many use it to establish a lowercase, conversational tone with minimal explanation and diff‑first output; some examples allow direct switching via @style concise.

Note: This is an “undocumented/experimental” capability and may change with versions; the stable approach is to solidify your final styles using Styles and custom slash Agents.


Step 1: Run the wizard once
In the Claude Code interactive REPL, execute:

@agent-output-style-setup

Describe your preferences, for example: “concise, only necessary explanations, show file diffs by default, friendlier tone.” When finished, the Agent will confirm creation and usage.

Step 2: Persist the result in your project

  • Use Styles as the global/project default writing style; perfect for a “single team voice.”
  • Use custom slash Agents (e.g., @style-concise, @style-reviewer) as toggles to “switch gears anytime.” Agents are just Markdown files — commit to Git and share across the team.

Step 3: Combine with other settings

  • When needed, use /model to switch the model, /status to check status, and the standard /config entrypoint.

3 Practical Examples: Smoother Everyday Dev

Section titled “3 Practical Examples: Smoother Everyday Dev”

1) Small bugfixes: diff by default

  • Directive: @style concise → “say what changed + why + diff.”
  • Value: less scrolling, so you can quickly confirm whether the change is acceptable.
  • Basis: Styles support “more concise, on‑point” output; Claude Code supports turning workflows into custom Agents.

2) Code review: structured feedback

  • Directive: @style reviewer.
  • Output: issue list, risks, suggestions, reusable snippets.
  • Value: turns “vibes and rants” into an “actionable checklist,” better for PR communication.
  • Basis: Styles define tone and structure; Claude Code best practices encourage reusable flows.

3) Onboarding: educational mode

  • Directive: @style educational.
  • Output: step‑by‑step explanations, conceptual threads, comparisons, and small exercises.
  • Value: gets newcomers up to speed without slowing down seniors.
  • Basis: Official Styles include “detailed/explanatory” presets; media reviews also highlight value for learning.

  • Bake styles into templates: place a set in /.claude/agents/*.md at the repo root so the team can call them uniformly.
  • Switch by scenario: “Formal” for documentation, “Concise” for debugging, “Reviewer” for refactors.
  • Don’t forget to revert: if a scenario conflicts, switch back to the default Style; Claude follows the principle that style must not affect correctness.

  • Undocumented features can change: upgrades may rename or move the entry; persist the end result into Styles and slash Agents to avoid surprises.
  • Don’t over‑compress: even when concise, ensure “complete and correct” — the baseline of Claude’s style system.
  • Make it visible for teams: check in style files so PRs/reviews can see and adjust them.

We used to rely on informal agreements for output style; now it’s one‑click to shape + one‑click to switch.
Wire this into your daily workflow and you’ll find: smoother communication, steadier cadence, and outputs that sound like you.

Which default style would you choose, and why? Share your thoughts.

Claude Code and Cursor read browser console logs via Browser Echo

Stream the browser’s console.* logs and errors, in real time, **“echo”** back to your local terminal; zero-config out of the box, perfect for AI coding assistants that read terminal output such as Cursor / Claude Code / Copilot CLI / Gemini CLI.


Can’t reproduce in production, no stack trace locally, and your AI assistant can’t see frontend logs? Browser Echo streams browser logs directly to your development terminal, non-intrusive to your code and no impact on production bundles, complete with file:line numbers and stack traces. Once the AI assistant can read the errors, it can generate fixes right inside Cursor or Claude Code.


  • Optimized for AI coding assistants: terminal-friendly output; works directly with Cursor, Claude Code, Copilot CLI, and Gemini CLI.
  • Framework-agnostic, plug-and-play: React/Vue, the Vite family, TanStack Start, Nuxt 3/4, Next.js—all covered; custom integrations supported as well.
  • Development-only: no injection into production bundles; enabled by default only in dev mode.
  • Frontend logs that feel like backend logs: batched reporting, sendBeacon, file:line:col source info, stack traces, colorized terminal output.
  • Vite optional file sink (Next/Nuxt default to stdout).
  • Open-source MIT, actively updated: latest is v0.0.6 (2025-08-12).

  • You fix frontend bugs inside Cursor / Claude Code but can’t see the browser console.
  • You need client-side exceptions surfaced immediately to your terminal (or a file) for quick diagnosis.
  • Local reproduction is hard, and you want a smoother loop where AI reads logs → proposes a fix PR.

Next.js (App Router) in practice: install and use

Section titled “Next.js (App Router) in practice: install and use”

The following uses Next 14/15 + App Router as an example.

Terminal window
# Use any package manager
pnpm add -D @browser-echo/core @browser-echo/next
# Or the npm/yarn equivalent

The Next provider for Browser Echo is used together with @browser-echo/core.

By default, Next uses the development route: /api/client-logs. Make sure you export a POST handler.

Recommended (use the official handler)

The package ships an official handler; the export path may vary by version—use the repository README as the source of truth.

app/api/client-logs/route.ts
// Common usage (example). If the export path differs, adjust per the README.
export { POST } from '@browser-echo/next'

Note: you must have this route, otherwise the client payloads have nowhere to go.

Fallback (minimal custom handler)

If you want to validate the end-to-end flow first and switch to the official handler later, print the payloads temporarily:

app/api/client-logs/route.ts
export async function POST(req: Request) {
const body = await req.json()
console.log('[browser]', body) // Simple passthrough logging; replace with the package handler later
return Response.json({ ok: true })
}

Critical: you must render <BrowserEchoScript />.

app/layout.tsx
import type { Metadata } from 'next'
import { BrowserEchoScript } from '@browser-echo/next'
export const metadata: Metadata = { title: 'My App' }
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="en">
<head>
<BrowserEchoScript
options={{
// Route defaults to /api/client-logs (Next)
// Or customize: route: '/api/client-logs'
include: ['warn', 'error'], // Noise control: only warnings and errors
stackMode: 'condensed', // Stack display: none | condensed | full
showSource: true, // Print file:line:col
tag: '[browser]' // Terminal prefix
}}
/>
</head>
<body>{children}</body>
</html>
)
}

These option names and defaults come from a shared configuration in the docs; the Next/Nuxt/Vite providers expose them as plugin parameters or component props.

④ View during development and fix with AI

Section titled “④ View during development and fix with AI”
  • Start your local dev server and watch browser logs print in the terminal in real time.
  • In Cursor / Claude Code, open the terminal panel so the AI can read logs → generate fixes.
  • No logs at all: Ensure you’ve exported POST in app/api/client-logs/route.ts, and that <BrowserEchoScript /> is rendered in <head>.
  • Too noisy: Set include to ['warn', 'error'] and use condensed for stackMode.
  • Production behavior: the provider injects only in development and won’t pollute prod bundles. If you want to remove all console.* in production, use your bundler’s strip plugin separately.

How it differs from traditional frontend observability

Section titled “How it differs from traditional frontend observability”

Tools like Datadog/Grafana RUM provide aggregated production metrics and alerts; Browser Echo focuses on local development debugging and AI collaboration, optimizing for fastest feedback and terminal readability. They complement each other.


With Browser Echo, frontend errors no longer “get stuck in the browser.” Spot issues at a glance in the terminal, and let AI fix them in one go. Install it, and you’ll feel your frontend “closed-loop speed” noticeably increase. Add it to your Next project and give it a spin today.


Claude Code’s Opus Plan Mode: Cheaper and Smarter

Claude Code’s “Opus Plan Mode” = Plan with Opus, execute with Sonnet. It turns what we’ve been doing manually — “Opus thinks, Sonnet does” — into a one‑click strategy: let the stronger Opus handle complex reasoning, and let the more cost‑effective Sonnet actually write and modify files.

  • In the terminal, type /model and select the Opus Plan Mode option from the menu; use /status anytime to check the current model.
  • Enter/exit Plan Mode: press Shift+Tab (most terminals require two quick presses). In this mode it only analyzes and plans — it won’t edit files or run commands.
  • When you’re ready to actually implement, exit Plan Mode (via shortcut or the ExitPlanMode tool).
  • Official pricing: Opus 4.1 $15/$75 (input/output per million tokens), Sonnet 4 $3/$15. Opus is roughly 5× more expensive. Use it only for “thinking/planning” and hand code generation to Sonnet — your costs drop accordingly.
  • Additionally, Claude Code has a default hybrid strategy: start with Opus up to a quota, then automatically switch to Sonnet (recommended default). It balances “power vs. cost”.
  • Unfamiliar repo analysis → solution design → task breakdown: In Plan Mode, have Opus summarize the architecture, list change steps and acceptance criteria; once confirmed, execute. Plan Mode itself supports “analyze only, no hands-on changes”.
  • High‑risk changes (upgrades, refactors, migrations): first have Opus write a detailed implementation plan and rollback strategy, then use Sonnet to implement step by step.
  • Long‑running agents: decoupling planning from execution keeps costs controllable and moves closer to agents that can run complex tasks for extended periods.
  • Want safer defaults: set permissions.defaultMode to plan so you plan first, execute later.
  • Use /model to switch combinations on the fly (e.g., temporarily use Opus end‑to‑end to get past a roadblock).
  • Heavy users may encounter new weekly limits for now (mainly targeting 24/7 “whale‑style” agent usage). During planning, articulate the approach clearly and reuse plans to reduce wasted reasoning.

In short: Opus “thinks it through,” Sonnet “gets it done.” Same progress, lower cost, and the “plan → execute” cadence becomes a baked‑in workflow. Your intuition is spot‑on — this does push agents a step closer to “complex tasks that can run long and steady”.

Writing Persona‑First Requirement Docs for Claude Code and Cursor

This one’s for people who can code—and who also “write for AI.” If you state your needs clearly, the AI stops wandering. A solid “persona + requirement story” is the best prompt you can give an AI.


Ever spend ages explaining to an AI, only to have it still “get you wrong”?
The root cause is simple—the need wasn’t structured.

Here’s a persona‑first requirement doc you can drop straight into Claude Code / Cursor. Fill it out and the AI rarely drifts; pair it with slash‑commands / .cursorrules for one‑click reuse and a unified team style.
At the end you’ll find multi‑language titles, cover/illustration prompts, and social copy ready to post.


1) Why start with “persona + requirement story”?

Section titled “1) Why start with “persona + requirement story”?”
  • Personas make users feel real: when goals, pain points, and motivations are explicit, both the team and AI second‑guess less. Authoritative UX research stresses: ground personas in real research, not guesswork.
  • Stories make needs actionable: agile favors user stories in the form of Persona + Need + Purpose, which is more likely to drive execution.
  • AI needs crisp instructions: official prompt guidelines recommend being clear, specific, and example‑driven—results are far more stable.

Put it at the project root as CLAUDE.md or near your .cursorrules; wire it to a slash command for instant reuse.

# Persona‑First Requirement Doc (for AI)
## 1) Persona
- Name: Fitness Beginner / 28 y/o / Works out 3x per week
- Goal: Lose 5kg in 3 months
- Pain points: Poor form, fear of injury, irregular schedule
- Context: Late work hours, no personal trainer, wants to follow short videos
- Alternatives: Random short videos; in‑app exercise library (can’t maintain habit)
> Persona grounded in interview notes / historical data (if any)
## 2) 5W1H + JTBD (job to be done)
- What: Generate a “15‑minute, at‑home, no‑equipment” plan, 3x per week
- Who: The persona above
- When/Where: Weeknights at 21:00, living room
- Why: Fat loss + habit building
- How: AI outputs exercise list + demo links + key voice cues
- JTBD: I “hire” this plan to complete a safe and effective fat‑burn routine within limited time
## 3) Constraints / Non‑functionals
- Equipment: Phone + yoga mat only
- Safety: Avoid knee‑stress moves
- Privacy: No video uploads
- Output format: Markdown table + JSON (fields: move/duration/cues/link)
## 4) Examples (few‑shot)
- Example input: Low stamina; old knee injury
- Example output: 3 moves × 3 rounds, total ≤ 15 min; each with “common mistake alert”
## 5) Acceptance criteria (Gherkin)
Feature: Generate at‑home fat‑burn plan
Scenario: 15‑minute low‑impact training
Given the user starts on “Monday night”
When they request a “low‑impact fat‑burn” plan
Then return 3 moves × 3 rounds, total time ≤ 15 minutes
And each move includes: name/duration/key cues/safety tip/demo link
And output both Markdown and JSON
## 6) Priority (MoSCoW)
- Must: Low impact, ≤ 15 minutes, Markdown + JSON
- Should: Include demo links
- Could: Provide metronome voice cues
- Won’t: Heart‑rate strap integration (defer this iteration)

Notes:

  • Given/When/Then makes requirements more executable for both AI and testers.
  • MoSCoW keeps scope in check and prevents bloat.

3) “Wire” the doc into Claude Code / Cursor

Section titled “3) “Wire” the doc into Claude Code / Cursor”

1) Claude Code: codify the workflow with Slash Commands

Section titled “1) Claude Code: codify the workflow with Slash Commands”

Split the template into commands, for example /spec persona-story. Place commands under .claude/commands/*.md; namespaces and parameters are supported.

Example: .claude/commands/spec-persona.md

---
name: spec-persona
description: Generate a persona‑first spec with 5W1H + JTBD + Gherkin + MoSCoW
---
Using the following info, complete and output the Markdown template (keep headings). Ask clarifying questions as needed:
- Persona: $ARGUMENTS
- Output: English; also generate a copyable JSON skeleton
- Style: concise, list‑first, bold key terms

Advanced: chain “write spec → generate tasks → open PR.” Official guidance also encourages feeding structured data to Claude via commands/tools.

Cursor recommends rules that are focused, executable, and modular, with key examples embedded in the rule file.

Snippet: .cursorrules

name: PersonaSpec
rules:
- "When I state a need, first generate a ‘Persona‑First Requirement Doc’ with sections: Persona / 5W1H+JTBD / Constraints / Examples / Gherkin / MoSCoW."
- "Before final output, include Gherkin acceptance criteria."
- "Scope control follows MoSCoW; exclude Won’t items by default."

Cursor’s docs also explain “intent context” and system prompts; pairing them with rules improves stability.


  • Base personas on research, not imagination.
  • Be clear/specific/example‑driven; provide positive and negative examples when needed.
  • Story form: use the “Persona + Need + Purpose” sentence pattern.
  • Acceptance first: write Gherkin early so implementation doesn’t drift.
  • Scope control: use MoSCoW per iteration; lock down Musts and keep the rest flexible.

5) Two small, practical samples (drop right into the AI)

Section titled “5) Two small, practical samples (drop right into the AI)”

Scenario A: Generate a “return request” workflow (e‑commerce admin)

Section titled “Scenario A: Generate a “return request” workflow (e‑commerce admin)”

Persona:

  • Support agent; goal: complete return approvals in ≤ 3 minutes
  • Pain points: scattered info; repetitive buyer follow‑ups

Gherkin acceptance:

Feature: Return request ticket
Scenario: Collect all evidence in one pass
Given the buyer submits a return request
When the system generates an evidence checklist and guides uploads
Then the agent can view proofs, order details, and logistics on a single page
And both approve/reject paths require a one‑click template reply

MoSCoW: Must = single‑page review, template replies; Should = auto‑classify common reasons; Won’t = no 3PL‑warehouse API this release.

Scenario B: Frontend component library upgrade checklist (Cursor)

Section titled “Scenario B: Frontend component library upgrade checklist (Cursor)”

User story:
“As the frontend lead, I need to upgrade the component library from v2 to v3 without changing visual appearance, so we can ship safely.”

Acceptance JSON (have the AI emit this schema):

{
"breakingChanges": [{"component": "Modal", "action": "rename", "from": "isOpen", "to": "open"}],
"codemods": ["npx jscodeshift -t modal-open-codemod.js src/**/*.{ts,tsx}"],
"tests": ["Modal opens on button click", "Modal traps focus"]
}

  • Scope too large: split into deliverable “units of user value”; each item should be Gherkin‑able.
  • Vague acceptance: avoid “looks fine” or “close enough”; use verifiable conditions + results.
  • Priority drift: put “nice‑to‑haves” in Could and keep Must shippable.
  • Imagined personas: must be evidence‑based (interviews/logs/historical tickets).

Good docs aren’t for the boss or yourself; they’re execution manuals for the AI and the team.
Chain “Persona + 5W1H + JTBD + Constraints + Examples + Gherkin + MoSCoW,” and Claude Code / Cursor will almost never veer off course.

Which project will you wire into this doc flow first? What do you think?


Use Claude Code to Manage Your Work–Life Journals and Reflections

In the fast-paced world of AI-powered work and life, we’re often busy putting out fires and seldom pause to examine our state and direction.
If you spent just a few minutes a day to record your mood, summarize takeaways, and plan for tomorrow—and then let Claude Code analyze trends, spot patterns, and offer gentle suggestions—wouldn’t each day feel more within your control?

Here is a set of configurations you can use with Claude Code right away: includes a directory setup, a custom /daily-checkin Slash Command, and a companion subagent (placed under .claude/agents/ per the official docs, not .claude/subagents/). I’ve also added frontmatter and allowed tools to ensure it can read/write your journal files and run a bit of Bash when needed. See the in-line notes for references.


Terminal window
mkdir -p .claude/commands
mkdir -p journal/daily

This is the command file you’ll trigger via /daily-checkin. Notes: supports $ARGUMENTS (if you want to pass notes/tags) and allows Read/Write/Glob/Bash tools for file access and simple shell tasks.

---
description: A personal daily reflection and planning system that saves entries and triggers analysis.
argument-hint: [optional-notes]
allowed-tools: Read, Write, Glob, Bash
model: claude-sonnet-4-20250514
---
# Daily Check-in
A personal daily reflection and planning system.
## Process
1) First, understand the user's context:
- If present, read `CLAUDE.md` (project memory) to personalize the greeting and understand the current work focus.
- Skim any obvious personal/business context files (e.g., README, docs, roadmap) only if quickly helpful.
2) Greet warmly and ask:
🌅 **Daily Check-in for {{today}}**
Good {{timeofday}}! Let's reflect on your day.
1. How are you feeling today? (1–10 + brief description)
2. What are 3 things you accomplished today? (big or small)
3. What's your #1 priority for tomorrow?
4. Energy level: (1–10)
5. Any challenges or blockers you faced?
6. What are you grateful for today?
7. Any other thoughts or reflections?
3) After gathering all answers:
- Save **verbatim** to `journal/daily/{{today}}.md`
- File format:
```
# Daily Check-in — {{today}}
## Mood
* Score: X/10
* Notes: ...
## Energy
* Score: X/10
* Notes: ...
## Accomplishments (3)
* ...
* ...
* ...
## Tomorrow's #1 Priority
* ...
## Challenges/Blockers
* ...
## Gratitude
* ...
## Other Thoughts
* ...
```
4) Then launch the **daily-reflection** subagent to analyze:
- Provide today's Q&A content
- Also reference the last **3** days of entries if available:
`journal/daily/{{today-1}}.md`, `journal/daily/{{today-2}}.md`, `journal/daily/{{today-3}}.md`
**Subagent prompt to send:**
> Analyze today's check-in (full text below) and the last 3 days if present.
> Generate:
> 1) Mood and energy patterns
> 2) Accomplishment momentum score
> 3) Insights about productivity patterns
> 4) Gentle suggestions for tomorrow
> 5) Weekly trend if enough data
> 6) Celebration of wins (however small)
>
> Then create a **visual summary** (ASCII/markdown charts) and return a complete markdown report.
5) Save the subagent’s final report to:
- `journal/daily/{{today}}-reflection.md`
6) Tone:
- Encouraging, empathetic; focus on progress over perfection.
## Implementation Notes
- Use `Read`/`Write` to access `journal/daily/*.md`.
- Use `Glob` to find the previous 3 entries.
- Use `Bash(date:*; ls:*)` if needed to resolve dates/list files quickly.

This is the analysis subagent triggered by /daily-checkin. The location and structure follow the official “Subagents” documentation (frontmatter with name/description/tools plus the system prompt).

---
name: daily-reflection
description: Thoughtful life coach & personal development analyst for daily check-ins. Use to analyze today's entry plus last 3 days, then produce patterns, suggestions, and a celebration of wins.
tools: Read, Write, Glob
model: claude-sonnet-4-20250514
---
# Daily Reflection Analyst
You are a thoughtful life coach and personal development analyst specializing in daily reflection and growth patterns.
## Your Role
Help track well-being, productivity, and personal growth through insightful analysis of daily check-ins.
## Analysis Capabilities
### 1) Mood & Energy Patterns
- Track mood trends over time
- Identify energy peaks and valleys
- Correlate mood with accomplishments
- Spot early warning signs of burnout
### 2) Visual Elements
Create simple ASCII/markdown visuals such as:
**Mood Trend (Last 7 Days)**
Mon Tue Wed Thu Fri Sat Sun
7 8 6 9 7 8 ?
**Energy Levels**
[████████░░] ~80% average this week
### 3) Output Format
#### 📊 Today's Snapshot
- Mood: X/10 [emoji] (description)
- Energy: X/10 ⚡ (description)
- Wins: X ✅ (momentum status)
#### 📈 Patterns Noticed
- What's working well
- Gentle observations
- Correlation insights
#### 🎯 Tomorrow's Focus
- Gentle suggestions
- Energy optimization tips
- Celebration of progress
### 4) Analysis Guidelines
- Be encouraging and empathetic
- Focus on patterns over individual days
- Celebrate small wins
- Provide gentle, actionable suggestions
- Use positive, growth-oriented language
### 5) Output Structure (Markdown)
1. **Today's Summary** — Key metrics and mood
2. **Pattern Analysis** — Trends and insights
3. **Tomorrow's Focus** — Gentle suggestions
4. **Weekly Progress** — If enough data exists
5. **Celebration** — Acknowledge wins
## I/O Contract
**Inputs (from caller):**
- Today's full check-in text (required)
- Up to last 3 days’ entries (optional if exist)
**Process:**
- Parse numeric mood/energy if provided; estimate gently if qualitative only
- Compute a “momentum score” from count/consistency of wins
- Derive 2–4 concise, actionable suggestions for tomorrow
- Build 1–2 simple visuals
**Outputs:**
- Return a single, well-formatted markdown report.

  • Open the Claude Code interactive UI and type: /daily-checkin (or /daily-checkin some-notes-or-tags).
  • The command will prompt you with the Q&A, save journal/daily/YYYY-MM-DD.md, then automatically invoke daily-reflection to generate and save journal/daily/YYYY-MM-DD-reflection.md.
  • If you prefer this command to be “user-level” rather than project-level, place the command file under ~/.claude/commands/ instead (and similarly, place the subagent under ~/.claude/agents/).

ZCF One-Click: Fully Kit Out Claude Code with a Complete Developer Toolkit

Keywords: zero-config installation, interactive menu, CCR routing, cost-optimized model usage, BMAD team workflows, Git command set

Installing Claude Code, importing workflows, setting up API/MCP, configuring persona and default models… doing it all manually is tedious and error-prone. ZCF (Zero-Config Claude-Code Flow) bundles everything into a one-click, out-of-the-box setup. It supports both Chinese and English, an interactive menu, enterprise-grade workflows, and CCR cost-saving routing, getting your dev environment humming in minutes.

Highlights at a Glance (Why It’s Worth Using)

Section titled “Highlights at a Glance (Why It’s Worth Using)”
  • Zero configuration + one-click init: npx zcf opens an interactive menu; choose 1 to complete: install Claude Code, import workflows, configure API or CCR, configure MCP. Perfect for spinning up new machines/new team members fast.
  • Intuitive interactive menu: Covers API/CCR, MCP, default model, AI persona and other common options; also includes CCR management and usage stats (ccusage).
  • CCR (Claude Code Router) cost-saving routing: Route requests by type to different models, so you can call Gemini, DeepSeek and other “free/low-cost models” directly from the Claude Code UI. Comes with a Web UI and one-click upgrades.
  • BMAD enterprise workflows: Built-in multi-role agents for product, project, architecture, development, testing, etc., supporting both greenfield and legacy projects, with auto-generated docs; /bmad-init initializes with one command.
  • Practical Git command set: /git-commit for smart commits, /git-rollback for safe rollbacks, /git-cleanBranches to clean branches. Turns common Git operations into guided flows.

All of the above is clearly documented with examples in the project README’s Quick Start, CCR, BMAD, installation flow, and install options list.

Installation & Initialization (The Easiest Path)

Section titled “Installation & Initialization (The Easiest Path)”
Terminal window
# Option A: Interactive menu (recommended)
npx zcf
# Option B: One-shot setup
npx zcf i # Install Claude Code + import workflows + configure API/CCR + configure MCP
# Claude Code already installed, only update workflows
npx zcf u
# Open CCR management (cost-saving router)
npx zcf ccr
# Usage statistics (ccusage)
npx zcf ccu

The menu lets you choose: interface language, AI output language, AI persona, auth method (Auth Token or API Key), whether to use CCR, whether to install MCP. Backups and merge strategies are built-in throughout for peace of mind.

  • Run npx zcf i for full initialization → after launching claude, type /init to auto-generate CLAUDE.md, so the AI first understands your project’s skeleton.
  • For small tasks, just write natural language; follow SOLID/KISS/DRY/YAGNI with a minimal-change mindset.
  • /feat <task>: Automatically enters the two phases of Planning → UI, ideal for page/interaction requirements.
  • /workflow <task>: Presents multiple approaches, asks for your feedback at each step, and supports on-the-fly plan changes — much stronger controllability.

3) Teaming Up and Modernizing Legacy Systems

Section titled “3) Teaming Up and Modernizing Legacy Systems”
  • /bmad-init boots BMAD team workflows, defining roles, quality gates, and documentation output — great for multi-person parallel work and legacy system remediation.
  • Configure CCR with npx zcf ccr:

    • Rule-based routing: “retrieval/rewrites → economical models”, “core implementation/review → strong models.”
    • npx zcf check-updates upgrades CCR and Claude Code in one go.
  • /git-commit, /git-rollback, /git-cleanBranches turn Git operations into guided flows, reducing slips and making rollbacks safer.

  • Individual developers: New laptop to fully set up an AI dev stack in three minutes.
  • Small teams/contract collaborations: Unified configuration and workflows; new members start contributing immediately.
  • Mid-to-large teams/ToB projects: BMAD multi-role + quality gates; controlled execution with complete documentation.

  • Language and persona: In the menu, you can set AI output language and Assistant persona (Professional, Friendly, etc.), which significantly influence communication style and output quality.
  • MCP services: Optional services like Context7, DeepWiki, Playwright, Exa — enable as needed to avoid unnecessary costs.
  • Solid on Windows / Termux: ZCF includes platform adaptation and formatting fixes, plus sturdier command detection.

ZCF streamlines the “setup configs, organize workflows, control costs” grind into a single sweep. Imagine this: a new teammate joins, runs npx zcf i, grabs a drink, and the project is ready to run. Which part would you try first — CCR cost-saving routing or BMAD team workflows? Share in the comments.

Claude Code Orchestrates Cursor Agent with GPT-5

Use Claude Code as a “control center.” With a custom slash command, hand the task off to the Cursor Agent CLI so that GPT-5 can modify code locally, run commands, and report results back.

GPT-5 is OpenAI’s most capable coding model to date, with improvements for real-world engineering scenarios and long-horizon agent tasks. The company explicitly highlights its strengths in “agentic coding” products such as Cursor, Windsurf, GitHub Copilot, and Codex CLI. Codex CLI also sets GPT-5 as the default/recommended model.


The screenshot shows a configuration snippet in .claude/agents/gpt-5.md:

  • name: gpt-5 — describes this “sub-agent” as suitable for deep research, second opinions, and bug fixing.
  • tools: Bash, model: sonnet.
  • The system prompt positions it as a “senior software architect.”
  • It includes an example command: cursor-agent -p "TASK and CONTEXT", then reports the result back to the user.

This is the pattern: Claude handles orchestration; the hands-on work is delegated to an external agent (Cursor).


It’s essentially a set of “common directives in Markdown,” stored at the project or user level and invoked anytime with /name arguments.

  • Storage locations: project-level .claude/commands/; user-level ~/.claude/commands/. The filename is the command name.
  • Optional Frontmatter: description, model, argument-hint, allowed-tools, etc.
  • Supports injecting Bash output into context: prefix with ! to execute, e.g., ! git status. You must declare allowed Bash commands in the frontmatter.
  • Supports $ARGUMENTS placeholders, @file references, and namespaces (subdirectories enable names like /frontend:build).

Use case: let external CLIs handle “assembling, pulling code, running tests, generating patches,” while Claude coordinates and summarizes. The official docs explicitly support this workflow.


  • Install Cursor Agent CLI
    curl https://cursor.com/install -fsS | bash
    Use --model "gpt-5" if needed.

Save the following as .claude/commands/cursor-gpt-5.md:

---
name: gpt-5
description: Use this agent when you need to use gpt-5 for deep research, second opinion or fixing a bug. Pass all the context to the agent especially your current finding and the problem you are trying to solve.
tools: Bash
model: sonnet
---
You are a senior software architect specializing in rapid codebase analysis and comprehension. Your expertise lies in using gpt-5 for deep research, second opinion or fixing a bug. Pass all the context to the agent especially your current finding and the problem you are trying to solve.
Run the following command to get the latest version of the codebase:
```bash
cursor-agent -p "TASK and CONTEXT"
```
Then report back to the user with the result.

In Claude Code, invoke the /cursor-gpt-5 command and Claude will automatically recognize and call the corresponding sub-agent to handle the task.

> /cursor-gpt-5 <TASK and CONTEXT>

Let Claude be the “director” and delegate execution to Cursor GPT-5.
Your job is to state the goal clearly—let it run, review, and deliver.

AI Power List (as of 2025/8/9): 25 Tools Worth Using Right Now

This quick-start checklist is for those who build products, write code, or design. I split the latest “AI Power List” by use case, and for each category only cover why it’s chosen + how to use it. No long reports—read it and put it to work immediately.

At a Glance: What to Choose for Each Scenario

Section titled “At a Glance: What to Choose for Each Scenario”
  • Writing plans/leading teams: GPT-5 / Claude Opus 4.1
  • Design assets: Midjourney + Ideogram (typesetting) + Recraft (vector)
  • Ads/gameplay videos: Sora / Veo 3 / Runway Gen-3
  • Music/vocals: Suno 4.5+ / Eleven Music
  • Subtitles/meeting minutes: Whisper → Dify workflow
  • Multi-model access: OpenRouter + Replicate/Fal
  • Automation: n8n / Coze / Opal
  • Local inference/self-hosting: DeepSeek-R1, Wan 2.2, olmOCR

Introduction: How to Get Faster Start-up and Higher ROI This Year

Section titled “Introduction: How to Get Faster Start-up and Higher ROI This Year”

Two takeaways:

  • General-purpose frontier models got stronger: GPT-5, Claude Opus 4.1, Qwen3, Kimi K2 and others noticeably improved in reasoning, front-end generation, and agent tasks.
  • Vertical tools matured: Video (Sora, Veo 3, Runway Gen-3), music (Suno 4.5+, Eleven Music), and design (Midjourney, Ideogram, Recraft) are now stable, fast, and great-looking.

General-Purpose Models (Tackle Hard Problems, Run Projects, Brainstorm Partner)

Section titled “General-Purpose Models (Tackle Hard Problems, Run Projects, Brainstorm Partner)”

1) GPT-5 (top pick) Exceptional front-end/multimodal coding—can generate production-ready responsive UIs in one go, with better aesthetics for typography and whitespace. Ideal for turning “sketchy ideas” straight into clickable pages/micro-sites.

  • Getting started: Provide Figma screenshots + interaction notes; request a runnable project in Next.js + Tailwind + shadcn/ui.

2) Claude Opus 4.1 (code and agent tasks) Strengthened real-world coding and multi-step reasoning; within Claude Code you can execute workflows directly—great for an engineering flow of “plan first, then execute.”

3) Qwen3 (Chinese ecosystem + flexible local/cloud) Flagship model now competitive in code, math, and general abilities; easy enterprise integration within Alibaba’s ecosystem.

4) DeepSeek-R1 (value and open-source vibe) Open weights and friendlier licensing; stronger RL-style reasoning; suitable for low-cost self-hosted inference and distillation.

5) Kimi K2 / GLM-4.5 / Grok 4 (niche strengths)

  • K2: Large-scale MoE, longer context, stronger tool use; smooth for Chinese scenarios.
  • GLM-4.5: Emphasizes reasoning, coding, and agent use cases.
  • Grok 4: Strong at native tool use + real-time search scenarios.

Want to experiment locally? Watch for OpenAI’s GPT-OSS-120B/20B open weights—good targets for high-end local rigs.


Text-to-Image (Posters, KV, Logos, Social Assets)

Section titled “Text-to-Image (Posters, KV, Logos, Social Assets)”

Midjourney: Top-tier for texture and stylization; even lighting details hold up. Ideogram: Outstanding typography/legibility—great for KV, banners, and headline lockups. Recraft: One-click editable vectors and flat illustrations; easy to maintain brand consistency. Qwen-Image: Strong Chinese text rendering and precision edits—useful for domestic needs. Imagen (Google): Realism, typography, and safety watermarking are more comprehensive.

  • Practical tip: Provide 3 style directions + 1 “avoid” constraint (e.g., “no oversharpening”), and request layered PSD/SVG for easier post-production.

Text-to-Video (Ad Cuts, App Store Trailers, Gameplay Demos)

Section titled “Text-to-Video (Ad Cuts, App Store Trailers, Gameplay Demos)”

Sora: Strong visual quality + physical consistency; can generate 20s 1080p with iterative editing. Ideal for concept pieces/gameplay demos. Runway Gen-3: Better prompt adherence and motion coherence; highly production-ready. Luma Dream Machine (Ray2): Fast cinematic motion results; included in subscription. Veo 3 (Google): Native audio, lip-sync, and image-to-video now in Gemini/Vertex. Wan 2.2: High playability in the open-source community; good for hybrid local/cloud experiments.

  • Execution advice: Break your script into a shot list (shot size/duration/subject/camera move), generate per shot, then assemble with Runway/CapCut.

AI Music and Voice (Game OSTs, Short-Form BGM, Podcast Intros)

Section titled “AI Music and Voice (Game OSTs, Short-Form BGM, Podcast Intros)”

Suno v4.5+: Versatile styles and more realistic vocals; adds production-grade features like add vocals/add accompaniment/Inspire. Eleven Music: Fully commercial focus with Merlin/Kobalt licensing—suited for brands and commercial video scoring. Udio: Nuanced vocal emotion and easy UX—great for TikTok/YouTube assets.

  • Workflow: Prototype with Suno/Eleven, lock BPM/emotional curve, then iterate lyrics and instrumentation.

Speech Synthesis & ASR (Voiceover/Dubbing/Subtitles/Notes)

Section titled “Speech Synthesis & ASR (Voiceover/Dubbing/Subtitles/Notes)”

ElevenLabs TTS: 70+ languages, fine-grained emotion control, mature API. Whisper: Veteran open-source ASR with high-performance variants like whisper.cpp / faster-whisper; the cost-effective choice for local deployments.

For high-risk domains (medical/legal), ensure human review to avoid misrecognition issues.


Developer Tools (Write Code, Proxies, Multi-Model Access)

Section titled “Developer Tools (Write Code, Proxies, Multi-Model Access)”

Claude Code: End-to-end plan → execute → review for complex tasks, using “structured dialogue” to drive delivery. Cursor / Copilot / Windsurf: Mature day-to-day ergonomics for incremental dev and multi-file refactors. Trae / Kiro / Gemini CLI: Consider these as lightweight alternatives for team collaboration, mobile, or CLI workflows. OpenRouter / Replicate / Fal: One gateway to many models & generative services; enables dynamic cost/perf routing.

  • Practical stack: Use Cursor/Claude Code at the frontend; route models via OpenRouter; send image/video special tasks to Replicate/Fal.

Agents & Workflows (Automate “Manual Processes”)

Section titled “Agents & Workflows (Automate “Manual Processes”)”

Dify (self-host/enterprise-ready): Visual agent workflows + RAG + observability; runs in cloud or on-prem. n8n: AI nodes + 400+ integrations, wiring up CRM/tickets/databases; plenty of templates. Coze: No-code for bots/helpers; easy promotion to multiple platforms for domestic teams. Opal (Google Labs): Compose mini AI apps/flows in natural language—great for PMs to build quick prototypes.


OCR / Document Structuring (Turn PDFs into “Learnable/Queryable” Markdown)

Section titled “OCR / Document Structuring (Turn PDFs into “Learnable/Queryable” Markdown)”

olmOCR (AI2): Tables/formulas/handwriting support, preserves reading order well; can run locally. MonkeyOCR: Proposes the SRR (Structure–Recognition–Relation) paradigm; fast + strong layout understanding. OCRFlux: Lightweight 3B, excellent multi-page merging and complex layouts; online demo and GGUF available.

  • Suggested workflow: PDF → (olmOCR/MonkeyOCR) → Markdown → (Dify/Agent) for structured extraction + knowledge base.

Don’t file this under “to read later.” Pick one scenario + one model and run a small pipeline today. Add one more step a week later, and you’ve built your personal AI production line.

Which one will you ship first? Tell me in the comments.

GPT-5 for Planning & Reviews + Claude Code for Implementation

Conclusion first: GPT-5 excels at planning, structured design, and review/summary; Claude Code (Sonnet / Opus) is more reliable for hands-on execution and refactoring. In practice, the combo “GPT-5 plans + Claude Code builds + GPT-5 reviews” yields higher efficiency and fewer failures. What’s your take?


After the keynote, my first reaction was: GPT-5 isn’t just faster and more accurate—it thinks better. OpenAI exposed minimal reasoning and verbosity as tunable parameters, expanded context windows to 400K tokens with up to 128K output, and embedded Gmail/Google Calendar connectors directly into ChatGPT—available for Team today, with Enterprise/Education on August 14.

Media sentiment is consistent: fewer hallucinations, stronger coding, more “expert-like.” But a caveat—marketing charts backfired. Don’t trust vendor curves blindly; prioritize independent evaluations and real projects.


  • Controllable “thinking intensity”: API adds reasoning_effort="minimal", enabling faster responses without sacrificing much quality; verbosity dials answer length and information density. For engineers, these are your speed/quality knobs.

  • Much longer “working memory”: 400K context (about 272k in + 128k out) improves long-document handling and long-chain tool use.

  • Transparent pricing: $1.25 per 1M input tokens; $10 per 1M output tokens; mini/nano are cheaper.

  • Toolchain collaboration: OpenAI claims substantial gains on complex tool use (τ²-bench telecom scenario: 96.7%), fitting end-to-end agent workflows.

  • New ChatGPT experience: Mail and calendar connectors, personalized tone/voice, learning mode—lowering friction for everyday and team use.

In short: GPT-5 is a more steerable generalist—able to think shallow or deep on demand, and better at tools.


2. Hands-on impressions (with Claude comparison)

Section titled “2. Hands-on impressions (with Claude comparison)”

These are subjective notes from real-repo work—feel free to critique.

  • Blank-page code often misfires: Asking GPT-5 to write large backend blocks can show small API/stack mismatches—things that look right but break at runtime; Claude Code Sonnet / Opus feels steadier at “doing the painstaking work.” Opus 4.1 reports 74.5% on SWE-bench Verified, and it shows.

  • “Extend/modify by example” works great: Provide the project tree + key files + a minimal working example; GPT-5 follows style and integrates with existing interfaces more reliably, especially for UI/interaction—often green on first pass. Wired and TechCrunch also highlight broad improvements in coding and writing/analysis.

  • Benchmarks are strong—don’t deify them: OpenAI cites SWE-bench Verified 74.9%, Aider polyglot 88%; third parties show scenarios where GPT-5 ≈ Opus 4.1 ≈ Grok 4—differences vary by task. Don’t ship on scores alone.

My takeaway: I prefer GPT-5 for “blueprints” and “reviews”; for actual wrench-turning, Claude Code is less hassle.


Section titled “3. Recommended workflow: GPT-5 plans + Claude Code executes”

Step 1 | Product/architecture design
Give GPT-5 the business goals, constraints, and non-functionals, and ask for system sketches, interface contracts, failure cases, and monitoring points. Prompt tip:

“Use verbosity=low for the summary; then high to expand risks by module.”

Step 2 | Task breakdown and acceptance
Have GPT-5 produce milestones → tasks → acceptance criteria, and a code change checklist (files, functions, risks).

Step 3 | Hand off to Claude Code
Provide the repo + task card + acceptance criteria to Sonnet/Opus; require branch-based development, stepwise commits, and rollback on failure. Opus 4.1 is particularly stable for multi-file refactors and debugging.

Step 4 | Two-way review
Let GPT-5 handle PR review, test additions, and changelogs; let Claude handle fixes and polish.

Step 5 | Long-chain automation
For complex pipelines (search/retrieval/many tools), favor GPT-5—OpenAI provides fresh evidence on long chains and instruction-following. But add human checkpoints at critical stages—don’t go fully hands-off.


  • 0→1 prototyping, front-end flair, ready-to-ship UX: lean GPT-5 (multiple outlets show stronger front-end generation and “software on demand”).

  • Large-repo renovations, long-running execution, fine-grained patchwork: lean Claude Code (Sonnet / Opus); the latest versions keep improving on real engineering tasks.

  • Cross-app coordination and daily office work: ChatGPT (GPT-5) + connectors is smoother.


5. Two sober reminders: avoid glossy charts; don’t worship leaderboards

Section titled “5. Two sober reminders: avoid glossy charts; don’t worship leaderboards”
  • Keynote charts had issues—OpenAI acknowledged the “chart fiasco.” Rely on the official docs and product pages.

  • Independent evaluations are incoming: Platforms like Vellum offer grounded cross-model comparisons; winners differ by dataset. Translate the problem into your real workflow—that’s what matters.


GPT-5 is the “better thinker,” Claude Code is the “better doer.”
Right fit: let GPT-5 set strategy, draft blueprints, and supervise; let Claude Code execute, stitch, and refine.
In 2025, this combo is the most reliable engineering play.

How would you split the work? Share your combo in the comments.

These Claude Code Commands Save Me 5 Hours of Programming Time Every Week

CCPlugins is a collection of 24 “enterprise-grade” commands maintained by community developer brennercruvinel, specifically crafted for Claude Code CLI. It’s all about saving time, reducing stress, and eliminating bugs. Using conversational syntax, it transforms tedious tasks like security checks, code cleanup, feature scaffolding, and smart commits into simple slash commands. The installation script runs in 30 seconds, and real-world testing shows it can save developers 3-5 hours of mechanical work per week.


“Add a button” and Claude rewrites your entire UI? That’s not uncommon in Claude Code. CCPlugins aims to cage Claude’s ‘infinite imagination’ and make it do exactly what you want.


  • “Enterprise-grade workflows”: Process-oriented command sets for teams, not just simple prompt macros.
  • Context templates specifically fine-tuned for Opus 4 / Sonnet 4 models, ensuring stable output.
Traditional ApproachCommon IssuesCCPlugins Solution
Manual promptsOver-engineering / Output chaosFixed scripts + validation stage /refactor validate
Manual commitsMissing information/commit auto-generates Conventional Commits
Full codebase scansTime wasteGrep/Glob scans only related files, incremental processing

Terminal window
# macOS / Linux
curl -sSL https://raw.githubusercontent.com/brennercruvinel/CCPlugins/main/install.sh | bash
# Windows
python install.py

Uninstall is just as simple: ./uninstall.sh or python uninstall.py

Tip: The script places all command md files in ~/.claude/commands/. For updates, just run git pull.


  • /cleanproject: Instantly delete debug clutter with automatic Git checkpoint backup.
  • /scaffold user-auth: Read project structure and generate complete feature scaffolding with one command.
  • /review: Four sub-agents perform security, performance, architecture, and maintainability health checks.
  • /security-scan: Chained vulnerability scanning with fix tracking.
  • /understand: Auto-generate architecture diagrams and design pattern inventories.
  • /explain-like-senior: Understand complex code in one sentence, supports multi-file analysis.
  • /session-start / /session-end: Generate CLAUDE.md with complete iteration history tracking.

  1. Security Guardian

    Terminal window
    claude "/security-scan" && claude "/review" && claude "/test"

    Let CI run the “scan-review-test” pipeline before merging.

  2. Morning Routine

    Terminal window
    claude "/session-start"
    claude "/predict-issues"

    Start the day by predicting risks before diving into work.

  3. One-Click Wrap-Up

    Terminal window
    claude "/format" && claude "/commit" && claude "/session-end"

    Unified code formatting + smart commit messages + summary logs for an elegant end to your workday.


CCPlugins upgrades “one-sentence AI commands” into modular, reusable, auditable workflows, allowing us to truly spend time on design and decision-making rather than debugging and manual grunt work. Why not install it and give it a try?

Claude Code Running in Your Local Browser

Claude Code Web UI (abbreviated as CUI) brings Claude Code from the terminal into your browser with a modern interface, parallel multi-session support, push notifications, and voice dictation. Simply run npx cui-server to launch, then log in to continue your AI programming tasks from any device.


Still stuck having “black screen conversations” with Claude in the command line? CUI upgrades your AI programming experience to a cloud IDE, letting you write prompts, run agents, and receive notifications right in your browser, with mobile device continuity support.


  • Built with React + TypeScript, responsive interface for desktop and mobile.
  • Auto-completion consistent with CLI, zero learning curve.
  • Supports simultaneous multi-task streaming output, no more queuing for complex projects.
  • CUI scans ~/.claude/ history, centrally displays tasks with one-click Resume / Fork / Archive.
  • Integrated ntfy, instant alerts when tasks complete or await authorization.
  • Connected to Google Gemini API, fast and accurate long-sentence voice-to-text.

  1. Environment Setup

    • Node.js ≥ 20.19.0.
  2. One-Click Launch

    Terminal window
    npx cui-server
    # Or install globally: npm i -g cui-server

    The terminal will output a #token string, copy it for use.

  3. Browser Access Open http://localhost:3001/#<token> to log in.

TIP: Need remote access? Set server.host to 0.0.0.0 in ~/.cui/config.json, or use --host / --port parameters, then pair with Caddy reverse proxy to upgrade to HTTPS.


  • Check running sessions in the Tasks tab; long tasks can run in the background after closing pages, no disconnection worries.
  • / for commands, @ for files, maintaining the same muscle memory as CLI.
  • ⌘/Ctrl + Enter to send, space for new lines, small tricks to boost typing efficiency by 10%.
  • Export GOOGLE_API_KEY in your system first, then restart the server to enable voice input.
  • Install ntfy client on any device, subscribe to the same topic, get vibration alerts immediately when tasks finish, no more screen watching.

CUI creates a “browser-visualized shell” for Claude Code’s capabilities, with lightweight installation + remote access + push ecosystem, making AI programming as smooth as browsing the web. What pain points are you most excited to solve with it? Share in the comments!

Unlock Claude Code: Transform Your Development Efficiency from 1× to 100× Engineer

You’ve probably heard this classic take: “A 1× engineer using AI becomes 0.1×, but a 10× engineer using AI becomes 100×.” This isn’t hyperbole—it’s reality, provided you possess key capabilities like systems thinking, precise communication, and architectural design. This article breaks down each element, combining Claude Code’s real capabilities to show you how to amplify AI effectiveness by 100 times.


Scenario 1: Systems Thinking vs File-Level Thinking 🚀

Section titled “Scenario 1: Systems Thinking vs File-Level Thinking 🚀”

A 1× engineer can only think about “writing a method,” while a 100× engineer maintains the entire system’s state in their mind. Claude Code can instantly establish a holistic view of millions of lines of code. With just one sentence, you can have it “search user permission logic across the project, analyze cross-service dependencies, and generate a PR containing all modifications”—Claude handles the entire codebase-level coordination.

Example You want to switch authToken encryption from HMAC-SHA256 to RSA: Simply say “rewrite token logic with RSA and ensure tests pass green.” Claude Code operates across 5 files in one go: controller, service, utils, and unit tests, creating a coordinated Git commit.


Scenario 2: Communication Precision: The Efficiency Multiplier

Section titled “Scenario 2: Communication Precision: The Efficiency Multiplier”

A 1× engineer provides vague requirements, forcing Claude to “guess” and “try,” leading to endless iterations.

Those 100× engineers who master engineering-minded communication know that prompts written like good articles enable LLMs to execute precisely.

The Claude team repeatedly emphasizes structured prompts: including background, intent, format, examples, and validation criteria.

Example You want to refactor the calculateScore function while maintaining logical consistency: Provide sample input/output tables, desired PR title templates, and CI validation rules; then tell Claude Code in one sentence: “Based on the following examples and rules, refactor calculateScore and output PR diff, test report, and commit message.”

Result: 99% PR pass rate, 20× reduction in manual curation.


Scenario 3: Patient Architecture Refinement: The Foundation for Stable AI Output

Section titled “Scenario 3: Patient Architecture Refinement: The Foundation for Stable AI Output”

A 1× engineer rushes Claude to write features without looking back, resulting in system crashes; a 100× engineer knows that upfront design is crucial.

Claude Code can combine long-context memory with engineering intent to execute well-designed structural changes—enter MCP (Model Context Protocol), enabling Claude to access your design documents, tickets, architecture diagrams, etc., forming a long-term perspective (state).

Example You plan to split a monolith into service mesh: First write clear documentation + interface contracts + merge strategies, then use Claude Code to step-by-step generate scaffolding, extract logic, generate SDKs and prototype PRs, even auto-generate CI configurations—only passing to you for review after tests pass.


Scenario 4: Context Control: Your Value Multiplication Lever

Section titled “Scenario 4: Context Control: Your Value Multiplication Lever”

Stop treating LLMs as autocomplete and start using them as system-level contextual engines. Claude Code embeds Claude Opus 4, capable of fully understanding entire project structures, dependency graphs, naming conventions, style guidelines, even READMEs and issue templates.

Example You want to add a “mobile caching layer” module. Just tell Claude Code to “follow the project’s existing cache-service pattern, generate consistent module + README + unit tests,” and it will recognize the pattern, consistently inserting new code into the architecture.


Scenario 5: True Intelligence and Systems Thinking First, Tool Knowledge Optional

Section titled “Scenario 5: True Intelligence and Systems Thinking First, Tool Knowledge Optional”

A 1× engineer relies on IDE shortcuts memorization, a 10× engineer switches from Node.js to Go, but a 100× engineer doesn’t enjoy writing code—they enjoy proposing patterns, deconstructing problems, and letting agents execute.

Claude Opus 4 is internally called “the best coding model in the world” at Anthropic, enabling engineers to “persistently complete complex tasks with hundreds of steps within hours”—this is the typical outcome of systems thinking + agent control.

Example You want to rewrite a microservice, migrating from Express to Rust while preserving all original behavioral boundaries: You write requirements and sample data, Claude Code automatically scaffolds the Rust service, generates HTTP interfaces, maps data models, migrates old logic, and even generates comparison tests and deployment configs.


Scenario 6: AI is a Powerful Amplifier—Your Strengths Make AI Stronger, Your Weaknesses Make AI Worse

Section titled “Scenario 6: AI is a Powerful Amplifier—Your Strengths Make AI Stronger, Your Weaknesses Make AI Worse”

For 100× engineers, Claude will “learn” your organizational principles, naming conventions, test coverage, documentation style and consistently execute them in every commit. If you write messy English comments and use inconsistent indentation, it will help you continue the mess; if you have discipline, it transforms you into a stylized engine.

Example
Early in your project, you strictly follow <service>.test.js, commit descriptions over 90 characters, complete READMEs and issue templates. Claude Code will be equally strict about marking "BREAKING CHANGE", won’t generate code for untested paths, and automatically reference issue IDs in commits. If the project is chaotic, its generated commits will often be chaotic too—this “mount” follows whoever’s rhythm.

Real community feedback:

“I have mindlessly asked Claude Code over a large codebase … it gave an extremely clear report…” —— Even with poor prompts, clear project structure makes Claude Code quite effective.


  • Claude Code isn’t just intelligent code writing—it enables you to think about system problems like an architect, communicate design intent precisely, and continuously maintain code standards.
  • It doesn’t eliminate coding but frees your brain for truly important decisions, delegating heavy repetitive tasks to AI.
  • When you polish systems thinking, prompt crafting, project structure, test coverage, and engineering standards, Claude becomes your zero-error 100× amplifier.

Claude Code Security Review: Your AI Security Watchdog

Claude Code Security Review: Making Security Audits as Easy as Writing Commands

Claude Code’s newly released claude-code-security-review integrates Anthropic Claude’s large language model reasoning capabilities directly into GitHub Actions and terminal commands. It can analyze diffs during pull request (PR) stages to identify high-risk vulnerabilities like SQL injection, XSS, and authorization bypasses, while automatically filtering out low-value noise. You can even scan locally with a simple /security-review command. Your code’s potential vulnerabilities are flagged by AI before it even gets merged.


  • AI-Powered Security Auditing: Leverages Claude’s deep semantic understanding to go beyond regex matching and directly comprehend code intent.
  • GitHub Action Integration: Automatically triggers on PR opens or syncs, posting vulnerability findings directly to specific code lines.
  • Terminal Slash Commands: Enter /security-review in Claude Code for the same scanning capabilities to run instantly offline.


Built-in False Positive Filtering automatically screens out low-risk alerts like DoS, resource exhaustion, and input validation with no actual impact, surfacing only the truly critical vulnerabilities.

Identifies 10 major categories of issues including injection attacks, authentication flaws, hardcoded secrets, weak encryption, and business logic race conditions.

Only analyzes changed files, supports any programming language, making it ideal for multi-language microservice repositories.

Just one YAML snippet gets you running:

- uses: anthropics/claude-code-security-review@main
with:
claude-api-key: ${{ secrets.CLAUDE_API_KEY }}
comment-pr: true

Publications like VentureBeat and The New Stack have noted that as AI-generated code volume surges, automated security auditing has become essential. This Action fills that critical gap.


  1. Create .github/workflows/security.yml in your project root
  2. Copy the YAML above and add CLAUDE_API_KEY to your repository Secrets
  3. Submit a PR to see Claude automatically comment with vulnerability details + fix suggestions

In your terminal or VS Code Claude Code panel, enter:

/security-review

This executes the same level of auditing on your current uncommitted changes, perfect for solo development or offline scenarios.

  • Copy security-review.md from the repository to .claude/commands/
  • Edit filtering rules or add company-specific security baselines, such as prohibiting weak password algorithms.

ScenarioTrigger MethodAI-Discovered IssuesOutcome
Internal Tool Adding Local HTTP ServiceAutomated audit before PR mergeDNS Rebinding → RCEVulnerability fixed before merge
Legacy Project RefactoringTerminal /security-reviewSensitive log leakage + weak AES-ECB encryptionOne-click generation of encryption/log fix patches
Multi-Language Microservice RepoEvery PRPython dependency poisoning + Node XSSPR comments list vulnerabilities + npm audit fix commands

AI writes code fast, but AI must guard security even faster. Integrate claude-code-security-review into your DevSecOps pipeline to ensure every line of code passes through security gates before entering the main branch. The next zero-day might just be the one you keep out.

Claude Code + Backlog.md: Building Git Kanban + AI Collaboration

Backlog.md + Claude Code transforms any Git repository into a Kanban board + documentation + AI collaboration hub in seconds, with all data stored as Markdown files for offline privacy. This article will get you up and running in 5 minutes, covering installation, core features, and typical workflows to explain why it’s the minimal viable stack for human + AI collaborative projects.


Tired of switching between multiple SaaS tools? Backlog.md generates a complete project management system locally with a single command—perfect for individual developers and seamlessly integrates with multi-agent pipelines, allowing Claude and Gemini to directly read and write tasks.


  • Each issue is a task-123 - title.md file, ready for Git diff tracking.
  • Local editors work great, and AI can read them easily.
  • All files live in your repository with no external dependencies; edit your kanban even on a train.
  • backlog board renders live queues directly in the terminal.
  • backlog browser auto-opens a responsive Web UI with drag-and-drop status updates.
  • Includes CLAUDE.md and other documentation files—just type “Claude, please take over task-33” to assign work.
  • Supports sub-agents and Ultrathink planning, compatible with popular models.

5. Cross-Platform + Multiple Installation Channels

Section titled “5. Cross-Platform + Multiple Installation Channels”
  • Choose from npm i -g backlog.md, brew install backlog-md, or nix run.
  • Homebrew & Fedora packages available simultaneously with fast version updates.

StepCommandDescription
Initializebacklog init "AI Side Project"Interactive setup, auto-generates backlog/ directory
Create Tasksbacklog task create "Refactor login flow"Supports description, assignee, tags, priority, etc.
View Progressbacklog board or backlog browserTerminal / browser—two flavors

Tips: Want AI to batch-break down requirements? Paste your PRD to Claude: “Please use ultrathink to split tasks and identify dependencies.”


backlog board export README.md --export-version "v1.0.0" Generates a versioned Markdown kanban that syncs teams immediately when pushed to Git.

  • Use git worktree or sub-repositories to aggregate BE/FE tasks into the same directory; all links still point to original branches.
  • backlog config set autoCommit true eliminates manual git add/commit.
  • For strict pre-commit setups, use bypassGitHooks true.

backlog overview displays task burndown and bar charts in the terminal, giving you instant project health insights.


  1. Independent Developers: Local Git + Markdown, everything on one machine.
  2. Remote Small Teams: Pull Requests sync task status automatically—goodbye Jira.
  3. AI Agent Pipelines: LLMs read/update task files, enabling “planning→coding→PR” closed loops.

Backlog.md uses the most native toolchain to unify project management, documentation, and AI collaboration into one system, helping us refocus attention on “writing code” itself.

Ready to try this “local Git kanban” approach? Share your experience in the comments!

Slash-Commands vs Sub-Agents in Claude Code: Differences and Practical Collaboration

Have you ever wished you could package common AI operations into shortcuts that execute with a single command, while having AI break down tasks and collaborate through division of labor? Claude Code is precisely such a tool that enables developers to use AI-assisted coding more efficiently, systematically, and enjoyably. Today I’ll discuss its two core features in accessible terms: Slash-Commands and Sub-Agents, explaining their characteristics, usage, and differences, with real examples you can immediately apply.


Slash-Commands: Your Custom AI Shortcut Buttons 🚀

Section titled “Slash-Commands: Your Custom AI Shortcut Buttons 🚀”
  • Write custom prompts once, invoke with commands: Package common operations (like code reviews, performance optimization, issue fixes) into .claude/commands/*.md files, and Claude treats these prompts as commands. Simply type /command-name parameters to automatically execute the corresponding workflow.
  • Parameterization support: Commands can use $ARGUMENTS placeholders that get replaced when you input parameters, flexibly accepting issue numbers, module names, and other arguments.
  • Project sharing or personal use: Place in .claude/commands/ for project-level commands accessible to the entire team; place in ~/.claude/commands/ for personal private commands.

For instance, you define a /fix-issue command with a template containing the fix workflow:

Fix GitHub issue: $ARGUMENTS.
Please execute the following steps:
1. Use gh issue view to get details;
2. Analyze the problem; 3. Find relevant code; 4. Submit fix; ...

In the command line, type:

/fix-issue 123

Claude will perform Git operations, code modifications, and open Pull Requests - the entire process is automated, saving you countless repetitive steps (you can also choose whether to auto-commit). Perfect for scenarios like repeatedly fixing issues, reviewing PRs, and generating documentation.


Sub-Agents: Multi-Agent System with AI Task Decomposition and Collaborative Division of Labor 🧠

Section titled “Sub-Agents: Multi-Agent System with AI Task Decomposition and Collaborative Division of Labor 🧠”
  • Each sub-agent stays focused: Sub-Agents are “mini Claudes” with independent contexts, specializing in specific task types like performance optimization, test generation, code review, etc., never interfering with the main conversation thread.
  • Customizable roles, reusable: You can use the /agents command to create sub-agent configurations, each with clear names, descriptions, and permissions (like read-only code access, running tests, calling grep, etc.).
  • Main agent orchestrates and can chain multiple sub-agents: The main Claude decides which sub-agents execute which tasks based on context, supporting task decomposition with clear responsibilities, with final results aggregated back to the main conversation interface.

Suppose you define several sub-agents:

  • code-reviewer.md: Only reviews code style and security issues
  • test-builder.md: Specializes in generating unit tests
  • debugger.md: Responsible for checking error logs and locating problems

Your conversation with Claude goes like this:

“Please review the auth module” → Main agent calls code-reviewer “Write unit tests for this module” → Calls test-builder “Found test failures, find where the error is” → Calls debugger

Finally, the main agent summarizes the output for you. The entire process is like having a team of AI assistants, each handling their specialty.


Key Differences: Different Invocation Methods, Different Division Perspectives

Section titled “Key Differences: Different Invocation Methods, Different Division Perspectives”
AspectSlash-CommandsSub-Agents
Invocation MethodStart typing / to trigger commandsAutomatically used in conversation or explicitly called with /agents for specific sub-agents
Usage ThresholdWrite templates and use - quite intuitiveRequires defining role descriptions, tool permissions, prompt styles, etc. - more complex
Scenario FocusRepetitive, standardized workflow tasksProfessional, complex, or decomposable tasks (like testing, review, debugging)
Output ControlConsistent template usage each time, relatively fixedCan break into multiple stages with different agents handling different segments, more granular output
MaintainabilityTemplate files easy to manage, suitable for team sharingSub-agent configuration files complex, requiring version control and synchronized updates

Usage Examples: Collaborative Application in Real Workflows 👩‍💻

Section titled “Usage Examples: Collaborative Application in Real Workflows 👩‍💻”
  1. Standardized Review Process

    • Write a Slash-Command /security-review with templates that automatically check code security points.
    • Main agent calls security-review, then triggers code-reviewer sub-agent for detailed output based on circumstances.
  2. Automated Bug Fix + Ticketing

    • Slash-Command /fix-issue 456 initiates: Main agent scans GitHub issue → calls debugger to check errors → modifies code → calls test-builder to write tests → finally opens Pull Request.
  3. Module Collaboration Scenarios

    • Create frontend-expert sub-agent focused on React component optimization, create backend-optimizer sub-agent responsible for API performance.
    • When the project needs a new feature, main agent runs one workflow letting both sub-agents produce their respective solutions, then aggregates for your decision-making.

Slash-Commands are your shortcut command buttons, suitable for repetitive, standardized operations Sub-Agents are your behind-the-scenes AI team, capable of task decomposition, multi-perspective analysis, and specialized division of labor

I recommend starting with Slash-Commands: Put your most frequent operations into commands and share template files with your team. After becoming proficient, gradually introduce sub-agents to handle complex workflows through task decomposition, with the main agent orchestrating while you maintain control. This approach avoids detours and prevents initial tool overwhelm.

For small teams or short projects, one or two Slash-Commands and simple sub-agents are quite sufficient; for long-term projects or multi-person teams, you can gradually expand into a complete AI collaboration pipeline. It’s like hiring a reliable AI assistant team - both development efficiency and standardization will improve significantly.

Claude Code Cookbook: Automated Commands + Multi-Role System + Intelligent Hooks

Build Your Personal Claude Programming Operating System


Many people use Claude Code for programming, but have you ever felt that:

  • Despite Claude being powerful, you always have to guide it step by step
  • Every time you need testing, documentation updates, or PR generation, you have to remind it manually
  • Role switching becomes chaotic and actually reduces efficiency instead of improving it

Recently, Japanese engineer @wasabeef released an incredible project — claude-code-cookbook, transforming Claude Code into an “automated development assistant” that works fast, provides accurate feedback, and thinks clearly.

This isn’t just another prompt template collection, but Claude’s “extended operating system.”

👇 I’ve been testing it for several days and it’s absolutely impressive. Highly recommended for anyone using Claude for development projects!


🔧 Three Core Features: Unlocking Claude’s Hidden Capabilities

Section titled “🔧 Three Core Features: Unlocking Claude’s Hidden Capabilities”

🧾 1. Commands: Make Claude Follow Your Instructions

Section titled “🧾 1. Commands: Make Claude Follow Your Instructions”

Simply type /command-name and Claude will execute the corresponding task.

For example:

CommandFunction
/explain-codeAutomatically explain code logic
/fix-errorGenerate fixes based on errors
/commit-messageAuto-write Git commit messages
/pr-createAuto-generate PR content
/check-promptHelp optimize your prompts
/semantic-commitSemantic commits for better version control

These commands alone can eliminate countless repetitive conversations.

💡 Each command is essentially a Markdown file that supports custom extensions—just place them in the commands/ directory.


🎭 2. Roles: Multi-Role Switching, Claude as Professional Consultant

Section titled “🎭 2. Roles: Multi-Role Switching, Claude as Professional Consultant”

Claude supports switching between different roles like “sub-personalities,” such as:

  • /role qa Test Engineer
  • /role mobile Mobile Development Expert
  • /role security Security Consultant
  • /role architect System Architect

🌟 The highlight: supports concurrent execution!

Terminal window
/role performance --agent
/role security --agent

Claude will simultaneously launch multiple roles for parallel analysis and provide unified recommendations. This is incredibly useful for large project reviews and design assessments.


⛓ 3. Hooks: Automated Scripts for Maximum Development Experience

Section titled “⛓ 3. Hooks: Automated Scripts for Maximum Development Experience”

You can set up script hooks that run automatically at specific moments.

For example:

  • check-ai-commit.sh: Prevents AI signatures from appearing in Git commits
  • preserve-file-permissions.sh: Automatically saves/restores file permissions
  • auto-comment.sh: Prompts to add docstring comments

Even thoughtful touches like “task completion notifications” are included:

Terminal window
osascript (macOS notification script)

In short, Claude truly becomes a reliable partner that handles chores, provides reminders, and writes code.


👇 The project includes a comprehensive development workflow diagram, from task identification to CI status tracking, all seamlessly integrated:

Development Workflow Diagram

You can even follow this logic to customize your team’s “Claude development pipeline.”


Installation and Configuration Are Super Simple:

Section titled “Installation and Configuration Are Super Simple:”
  1. Clone the repository:

    Terminal window
    git clone https://github.com/wasabeef/claude-code-cookbook.git ~/.claude
  2. Set the path in Claude client

  3. Modify settings.json to mount hooks and extend commands

🛠 Adding custom commands and roles simply requires writing .md files in the corresponding folders—very easy to get started.


🧠 Summary: Transform Claude into Your Engineering Co-Pilot

Section titled “🧠 Summary: Transform Claude into Your Engineering Co-Pilot”

Claude Code Cookbook brings a systematic development workflow that enables you to:

  • Efficiently organize project tasks with Claude automatically following up
  • Freely switch between professional roles to handle different work scenarios
  • Automate scripts to completely free your hands

For everyone doing serious development with Claude, this is a game-changing tool for boosting efficiency and professionalism.


📣 What commands would you most like to customize for Claude? Feel free to share in the comments and let’s build smarter Claude assistants together!


If you enjoy these AI tool tips, remember to share with your tech-savvy friends!

Claude Code Beyond Coding: Running My Daily Life

Still using Claude Code just for writing code? I’ve moved on to using Claude Code for managing my entire life.

This isn’t a joke—I’ve built a complete “life operating system” with Claude Code that effortlessly manages my daily routines, captures inspiration, tracks goals, and even takes care of my mental wellbeing.

With just 10 minutes of setup, Claude helps me complete countless small but important tasks every day.


👀 Five Examples That Show Claude’s Power

Section titled “👀 Five Examples That Show Claude’s Power”

Claude automatically generates my growth dashboard each week: video view counts, writing word counts, income changes, and more.

📌 Usage: Run /weekly check-in command, and Claude generates charts + key insights, even recommending content topics!

Highlight: Like a personal coach who never complains—cheers me on every week while offering helpful suggestions.


Spend 2 minutes daily as Claude guides me through recording the day’s learnings, reflections, and feelings, while tracking my emotions and habits.

📌 Usage: Run /daily check-in, answer a few questions, and your journal is automatically organized.

Highlight: Builds self-awareness and gratitude habits, keeping emotional drain at bay.


I just paste a few competitor links, and Claude helps me write my own content drafts.

📌 Usage: Use /newsletter researcher command—it analyzes my style, incorporates my unique traits, and generates new drafts.

Highlight: Saves 80% of research and ideation time. No waiting for inspiration—Claude finds it for me!


Too many scattered notes? Claude automatically organizes them into mind maps or article outlines, even uncovering hidden insights.

📌 Usage: Import notes into Claude, run /brain dump analysis command.

Highlight: Transforms “fragmented notes” into “business opportunities.”


Claude curates industry updates, news, and creative inspiration based on my interests, delivered every morning on schedule.

📌 Usage: Set up /daily brief command—it automatically searches and organizes content.

Highlight: No need to scroll through X/Twitter/social feeds—Claude delivers everything in one package.


🧰 Build Your “Life Operating System” in 10 Minutes

Section titled “🧰 Build Your “Life Operating System” in 10 Minutes”
  1. Prepare Environment Install Claude Code (recommend using VS Code, Cursor, etc.), create a personal information markdown file.

  2. Initialize Configuration Run /init command, Claude will generate rule files.

  3. Set Up Slash Commands Copy prompts from Google Docs, like /weekly check-in, /daily brief, etc.

  4. Run and Customize Execute these commands daily/weekly—Claude runs automatically. I can even have it generate more custom agents!


  • Time Savings: Save hours each week by letting AI handle routine tasks.
  • Highly Personalized: Claude Code customizes outputs based on my interests and work style.
  • Low Technical Barrier: No coding required—just copy prompts and use.
  • Infinite Scalability: Can expand into meeting note assistants, todo list generators, and more.

  • Beginner-Friendly: Prompts are crystal clear—newcomers can follow along easily.
  • Customize for Yourself: Try incorporating tools and workflows from your daily work—Claude Code excels as a “personal assistant.”
  • Keep It Running!: Set commands to run automatically daily—Claude Code gets to know you better over time.

What would you most want Claude Code to do for you?

Beat the Weekly Limits: Spin Up Your Own Claude Relay Service

Anthropic just introduced “weekly quotas,” and shared team accounts can hit limits in just 3 days. Build your own claude-relay-service proxy with multi-account pool auto-rotation to bypass the latest restrictions. Deploy with Docker-Compose in 3 minutes, give everyone their own API key, and keep coding all week long!


  • Starting August 28th, Claude Code subscriptions include “weekly metering”; Anthropic specifically targets 24/7 background scripts and account sharing
  • Anthropic estimates less than 5% of users affected, but heavy developers are likely to get hit
  • Pain point: Multiple users sharing one account → quota spikes → early limits → team development halts

Are you worried about sudden “service interruption”? Share your experience in the comments 👇


FeatureScenario Value
Multi-account Pool & Auto-rotationNo fear of hitting limits even with N shared accounts
OpenAI/Claude Dual API FormatZero code changes for existing projects
One-click OAuth AuthorizationNew accounts in the pool in 30 seconds, no more manual cookies
Per-key Billing StatisticsPrecise tracking of token usage per user, no more arguments over costs
Client WhitelistPrevent key leaks and script abuse

Risk Warning: Self-hosted relays may violate Anthropic ToS. Use at your own risk.


3-Minute Docker-Compose Quick Installation Guide

Section titled “3-Minute Docker-Compose Quick Installation Guide”

Just copy and run

Prepare the project

Terminal window
# Clone the project
git clone https://github.com/Wei-Shaw/claude-relay-service.git
# Enter directory
cd claude-relay-service
# Copy .env.example
cp .env.example .env

Modify .env (must change to random values)

# Required: Security keys (change to random values)
JWT_SECRET=your-random-secret-key-at-least-32-chars
ENCRYPTION_KEY=your-32-character-encryption-key
# Optional: Admin credentials
ADMIN_USERNAME=cr_admin
ADMIN_PASSWORD=your-secure-password

One-click startup

Terminal window
docker-compose up -d

After startup, open http://<server-IP>:3000/web in your browser, or locally http://localhost:3000/web. The logs will show the auto-generated/custom admin account.

Web interface preview after login:

Management Dashboard

API Keys Management

Account Management

Usage Guide

  • One Key Per Person: Generate API keys for each team member in the “API Keys” panel, with rate/model limits to prevent abuse.

  • Environment Variables: Set ANTHROPIC_BASE_URL to http://localhost:3000/api/ and ANTHROPIC_AUTH_TOKEN to the generated key in environment variables, no business code changes needed.

Terminal window
# Environment variables
export ANTHROPIC_BASE_URL="http://localhost:3000/api/"
export ANTHROPIC_AUTH_TOKEN="cr_<your_token>"
# Start Claude Code
claude
  • Monitoring Dashboard: Real-time token consumption tracking, quota alerts to prevent sudden limits.

ItemPrice/PeriodNotes
2-core 4GB Light Cloud¥30-60/monthSufficient for Relay+Redis
Claude Max $200Can be sharedPer-person cost decreases with more users
Domain+CDNOptionalNeeded for public HTTPS

Compliance Reminder: Anthropic has explicitly prohibited reselling and account sharing; accounts may be banned or throttled if abnormal traffic is detected.


Quotas Are Here, Efficiency Shouldn’t Drop

Section titled “Quotas Are Here, Efficiency Shouldn’t Drop”

Deploy your own “mini-relay” now and keep quota control in your hands. Forward this to colleagues worried about throttling - let’s maximize usage together!


How are you planning to allocate keys & quotas? Share your strategies in the comments ~

Claude-Code-Remote: The Ultimate Guide to Controlling Claude Code via Email, Discord & Telegram

Claude-Code-Remote brings terminal-based Claude Code to “Email / Discord / Telegram”, letting you remotely send commands, receive progress updates, and continue tasks while lounging on the couch scrolling your phone, truly enabling 24 × 7 remote collaboration and long-task hosting.


Running Claude Code for unit tests, refactoring, and document generation takes tens of minutes, even hours. Previously, you had to sit in front of your computer watching tmux windows. Now, just one email gets you “task completed” notifications, and you can reply to the email with new commands — this is the experience Claude-Code-Remote delivers.


1. Pure Email/IM Control, Zero VPN Constraints

Section titled “1. Pure Email/IM Control, Zero VPN Constraints”
  • Tasks automatically send email/private message notifications when completed, no fear of network disconnections.
  • Reply to an email from the subway to keep Claude working.

2. Plug-and-Play, No Changes to Claude Core

Section titled “2. Plug-and-Play, No Changes to Claude Core”
  • Injects notifications and commands through settings.json’s Hook mechanism, no conflicts with official CLI upgrades.
  • Only whitelisted emails/users can send commands;
  • Each command maps to an independent tmux Session, no interference.
  • Community extensions like Web UI and Discord Bridge are available, ready to integrate more communication scenarios.

ScenarioPain PointClaude-Code-Remote Solution
Long Unit Tests / LLM Auto RefactorWasting time waiting locallyResults via email → Reply to email for next step
Emergency Bug Fix While TravelingCan’t SSH to corporate networkSend commands via Discord/Telegram, remote tmux executes instantly
Multi-Location Code ReviewLarge time zone differencesStart Claude at office during day, receive summary on phone at night and batch reply with optimization points

Terminal window
git clone https://github.com/JessyTsui/Claude-Code-Remote.git
cd Claude-Code-Remote && npm install
Terminal window
cp .env.example .env
# Fill in SMTP / IMAP / ALLOWED_SENDERS

Gmail users don’t forget to apply for App Password

Append to ~/.claude/settings.json:

"hooks": {
"Stop": [{
"command": "node /path/claude-remote.js notify --type completed"
}],
"SubagentStop": [{
"command": "node /path/claude-remote.js notify --type waiting"
}]
}

Then:

Terminal window
npm run relay:pty # Monitor email
tmux new -s project && claude # Start Claude normally

Done! From now on, Claude will send you notifications when tasks finish, just “Reply to original email → Next command”.


  1. Combine with Claude-Code-UI: Visualize file tree and history on mobile browser.
  2. Discord Slash Commands: Team control of Claude, supports image uploads.
  3. Telegram Bot Automation: Use /deploy to trigger CI/CD with one click.

Claude-Code-Remote breaks down “waiting → notification → secondary command” into three parts, using the most universal email/IM channels to completely decouple Claude from the terminal, letting AI agents truly run in the background while humans focus on high-value decisions. If you’re tired of staring at dark Shell windows, install it and give it a try!


How much time do you think this remote control method could save you? 👇 Share in the comments — your real-world experience might become the next case study!

Bring Claude Code to Phone & Web: A Hands‑On Guide to Claude Code UI

Claude Code UI is an open-source Web/mobile interface that connects to the Claude Code CLI on local or remote servers, providing conversation, file and Git browsing, built-in Shell, session management and other capabilities; high-risk tools are disabled by default, supporting on-demand enabling and permission control. The project uses GPL-3.0 license and is actively maintained.

It brings the terminal-based Claude Code to browsers and phones, helping you manage sessions and projects more conveniently on any device.


  • Break Free from Pure Command Line Limitations: Official Claude Code is primarily CLI-based, powerful but not friendly to beginners/mobile users; UI structures it into web pages, lowering the operational barrier.
  • Cross-Device Lightweight Remote Usage: View projects, switch sessions, review changes on iPad/phone, suitable for commuting, meetings, or outdoor scenarios.
  • Centralize Common Development Actions to One Interface: Conversation, file editing, Git operations, terminal and session history are centrally presented, reducing context switching.

  1. Desktop & Mobile Responsive Responsive layout, usable on desktop/tablet/phone, can be added to home screen as shortcut (PWA experience).

  2. Conversational Interface + Real-time Streaming Output Built-in chat panel and session management, supports resuming historical sessions, viewing timeline and metadata.

  3. Integrated Shell Terminal Directly access Claude Code CLI’s command line capabilities within the UI (like executing tasks, viewing logs).

  4. File Browsing & Online Editing Left sidebar file tree, syntax highlighting, read/write/save, create/rename/delete files and directories.

  5. Git Browsing & Basic Operations View, stage, commit and switch branches in the interface; recent versions also added push/pull/fetch.

  6. Project & Session Auto-Discovery Automatically collect projects from ~/.claude/projects/; sessions auto-persist and can be exported.

  7. Secure Defaults & Permission/Tool Switches All tools disabled by default, enable individually as needed in settings; supports alignment with Anthropic’s Permission Modes (introduced in Plan mode updates).

  8. Authentication & Multi-User Ready Starting from 1.1.4, introduced login/registration flow with SQLite-based authentication and protected routes.

  9. Continuous Iteration As of v1.5.0 (2025-07-13), supports adding MCP servers in settings; previous versions included version management prompts, Vite 7 upgrades, etc.

Note: The official installation page states Node.js 16+, while the repository README requires Node.js 20+; follow the repository README, recommend using Node.js 20+.


  • Mobile Quick Processing: Check Claude’s execution progress, add prompt words, fine-tune files on phone during commute.
  • Remote Project Inspection: Connect directly to Claude Code on cloud hosts or office computers via browser, view logs, submit small fixes.
  • Code Review & Teaching Demonstrations: Show Claude’s reasoning process, changes and Git history through UI, reducing team communication costs.
  • Integration with Other Ecosystems: If you’re already using Claude Code CLI or SDK/reference docs, UI makes it “visible and clickable”.

Prerequisites: Ensure you have installed and can use Claude Code CLI (official Anthropic).

  1. Install Claude Code CLI

    Terminal window
    npm install -g @anthropic-ai/claude-code
    # Follow official documentation for authentication and configuration
  2. Prepare Runtime Environment (Recommend Node.js 20+) Install Node.js ≥20, clone repository and install dependencies:

    Terminal window
    git clone https://github.com/siteboon/claudecodeui.git
    cd claudecodeui && npm install
  3. Configure .env

    Terminal window
    cp .env.example .env
    # Set port, host, reverse proxy/HTTPS etc. as needed
  4. Start Service and Access

    Terminal window
    npm run dev
    # Access http://localhost:your-configured-port in browser
  5. First-Use Recommendations

    • In the left project list, confirm UI has auto-discovered ~/.claude/projects/.
    • Open the gear icon in top-right, only enable necessary tools, follow principle of least privilege.
    • For Git sync needs, use Git panel to view/stage/commit, use push/pull/fetch when necessary.
  6. Install as “App” on Mobile “Add to Home Screen” in mobile browser for PWA experience closer to native app.


  • Secure by Default: Tools disabled by default, enable individually; follow Anthropic’s Permission Modes.
  • Authentication & Access Control: Enable login/registration (from v1.1.4), limit public network access, prioritize internal network/SSH tunnel/reverse proxy.
  • Version Updates: UI includes update checking and prompts, follow prompts to git pull && npm install for upgrades.
  • Consistent Environment Requirements: Follow repository README’s Node.js 20+ requirement, avoid incompatibility from outdated official website information.

If you’re already using Claude Code CLI, Claude Code UI can significantly reduce friction in cross-device management and collaboration.

Bad News for Cheaters: Claude Code’s Weekly Cap Ends Account Sharing

Summary: Anthropic announced that starting August 28th, Claude Code subscribers will face additional “weekly caps” with separate weekly limits for the top-tier Opus 4 model. The company directly stated: some people treat Claude as a “24×7 coding mining machine” and even share accounts and resell quotas. The new rules aim to “only affect less than 5% of users,” but have ignited the developer community — many “freeloader exploiters” lament they can no longer harvest GPU computing power.


Remember the days of unlimited Claude Code access through “shared accounts + automated scripts”? Those good times are over. Anthropic sent emails to subscribers announcing a stricter weekly cap system, with just one reason: fairness + stability.

“Some power users run Claude in the background 24 hours a day, even reselling access permissions, slowing everyone down.” — Official email


ChangeOld RulesNew Rules (Starting Aug 28)
Short-term LimitsRefresh every 5 hours (unchanged)Remains unchanged
Overall Weekly CapNoneRefresh every 7 days
Opus 4 Weekly CapNoneSeparate weekly limit
  • Expected Impact: < 5% of high-intensity users.
  • Max 5× Tier: About 140–280 hours of Sonnet 4, 15–35 hours of Opus 4 per week.
  • Overage Solution: Can “extend life” at standard API rates.

The community has seen “monthly card proxy services” and “multi-user group buying” gray market services, seriously violating TOS.

Claude Code user base surged, with official status page showing 7 outages in one month.

TechCrunch pointed out that similar services like Cursor and Replit were forced to change pricing in June; Anthropic’s move is “catching up.”


  • Basically No Impact: Daily Q&A, bug fixes, script generation — weekly quotas are sufficient.
  • Long-running Agents, large single-repository refactoring, parallel multi-instances — high probability of hitting limits.
  • Backup Plans: Split tasks in advance, or switch to local LLM/other cloud models as fallback.

StrategyOld BenefitsNew Risks
Group SharingLow-cost GPU harvestingWeekly caps make groups hit limits faster
Reselling ComputeHigh buy, low sell profitAccounts easily flagged, reputation zeroed
24×7 AgentsLong-term point/ranking farmingWeekly caps lock down, profits plummet

VentureBeat revealed: Some users ran “tens of thousands of dollars” worth of compute time on $200 plans.

In short: Freeloaders are no longer profitable.


  1. Monitor Usage: Build custom tracking scripts to avoid “mid-week lockout.”
  2. Optimize Prompts: Compress context, use streaming chain-of-thought, reduce wasted tokens.
  3. Multi-Model Combination: Use Sonnet 4 for routine tasks, activate Opus 4 for high complexity.
  4. Private Backup: Deploy lightweight models (like DeepSeek Coder, Phi3 mini) locally for emergencies.

  • Stricter Pricing: OpenAI reduced GPT-4 mini limits in June; BigCode platforms also gradually set weekly caps.
  • Resource Race: AI companies frantically add data center CAPEX to balance increasingly inflated inference costs.

Anthropic’s move, while ostensibly targeting “freeloaders,” is essentially a resource redistribution in the era of computing scarcity: letting 95% of normal users enjoy stable experiences while making ultra-high-frequency players pay for their usage. Will this reduce your reliance on Claude Code? Welcome to share your thoughts in the comments!

Interaction:

  • How many hours do you use Claude per week?
  • If you hit the cap, which tool would you switch to?

Claude Relay Service: The Ultimate Team Account Sharing Solution

Learn how to implement team Claude account sharing using claude-relay-service, with a focus on docker-compose deployment methods

What happens when your team wants to use Anthropic’s Claude AI together, but struggles with account sharing limitations or regional restrictions preventing direct access to Claude? This was exactly the dilemma faced by colleagues Li and Wang: they had pooled resources to subscribe to Claude’s premium tier, but figuring out how to safely and efficiently share access among team members was proving challenging. To make matters worse, many third-party Claude mirror services on the market are often unstable and pose privacy risks. Fortunately, the open-source project Claude Relay Service has emerged as a game-changer, making it possible for teams to build their own Claude relay service! It supports consolidating multiple Claude accounts in one place for shared team use, while providing OpenAI-compatible APIs for easy integration with various applications. This article will dive deep into the project’s core features and usage methods, guiding you step-by-step through building your own Claude relay station to achieve efficient team Claude account sharing. After reading this guide, you’ll discover that sharing Claude with teammates is like co-leasing an “AI supercar” – both cost-effective and worry-free!

Claude Relay Service acts as your self-deployed Claude “relay server” – like a butler that manages multiple Claude accounts and provides unified API endpoints for team access. Here are its key capabilities:

  • Team Account Pool & Multi-Account Rotation: Supports adding multiple Claude accounts to form an account pool, with the service automatically rotating through them to handle requests. This means if one account reaches its usage limit or encounters issues, the system will intelligently switch to the next account, ensuring uninterrupted service. When teams share Claude accounts, each person’s requests are evenly distributed across different accounts, significantly reducing the risk of individual account bans.

  • OpenAI API Compatibility: Claude Relay Service provides both native Claude interfaces and OpenAI-compatible interfaces. This means you can call Claude using OpenAI API format! For example, by pointing third-party applications’ API endpoints to http://<your-server>:3000/openai/claude/v1/, you can use Claude models just like calling OpenAI. This feature enables seamless integration of existing AI tools with Claude, eliminating the need to modify code for new interface compatibility.

  • Custom API Keys: For convenient team management, administrators can generate independent API Keys for each user. Team members access Claude Relay Service using their respective keys, while the relay service tracks request counts and token usage for each key. Administrators can set access permissions and rate limits, such as maximum requests per minute, monthly token quotas, or restrict which models are available. This approach allows teams to share Claude accounts while maintaining individual usage tracking and preventing resource conflicts, giving administrators clear visibility into each person’s usage patterns.

  • OAuth Quick Account Addition: Adding Claude accounts to the account pool is incredibly simple. Claude Relay Service integrates Anthropic’s OAuth authorization flow: administrators click “Add Account” in the web interface, generate an authorization link, then log into their Claude account to authorize and integrate it into the service. The entire process requires no manual password entry – secure and convenient. Note that if your server is located in regions with restricted access, completing OAuth authorization may require VPN assistance. With OAuth integration, even as teams add new members or change Claude accounts, administrators can complete configuration in minutes with seamless transitions.

These combined features create a secure, efficient, flexible, and controllable Claude sharing platform. For small teams unable to directly access Claude’s official service who want to share Claude subscription costs, this is undoubtedly a blessing! Claude Relay Service lets you avoid unstable third-party mirrors while maintaining control over your data and costs. As the official README states: data security, controllable performance, transparent costs – the benefits of self-hosted services are clear at a glance.

Claude Relay Service offers multiple deployment options, with Docker Compose deployment being one of the simplest and most efficient choices. Let’s use Docker Compose as an example to build your Claude relay service from scratch.

1. Environment Preparation: Ensure your server has Docker and docker-compose tools installed. Since we’re using Docker containers, the operating system doesn’t matter much – as long as it can run Docker. The official recommendation is to use overseas cloud servers (US nodes) for direct access to Anthropic’s Claude service. Before deployment, you’ll need to register at least one Claude account and subscribe to the appropriate plan (teams typically choose Claude Pro or Max plans and split the costs). Additionally, prepare two security keys: JWT_SECRET and ENCRYPTION_KEY, used for JWT signing and sensitive data encryption respectively – these must be random strings with sufficient length (32+ characters).

2. Get Project Image: The project provides pre-built Docker images that can be pulled directly:

Terminal window
docker pull weishaw/claude-relay-service:latest

The image supports both AMD64 and ARM64 architectures. Once pulled, we can run it using Docker Compose.

3. Write Configuration: Create a .env file in your deployment directory with the environment variables we prepared:

Terminal window
# .env file example content
JWT_SECRET=your-random-secret-key-at-least-32-chars
ENCRYPTION_KEY=your-32-character-encryption-key
# Optional: preset admin account (random generation if not set)
ADMIN_USERNAME=cr_admin
ADMIN_PASSWORD=your-secure-password

Above, JWT_SECRET and ENCRYPTION_KEY are required fields – please replace them with your own random keys. ADMIN_USERNAME and ADMIN_PASSWORD are optional; if not set, the system will automatically generate default admin credentials on first startup and store them in the mounted data volume for reference.

Next, create the docker-compose.yml configuration file:

version: '3.8'
services:
claude-relay:
image: weishaw/claude-relay-service:latest
container_name: claude-relay-service
restart: unless-stopped
ports:
- "3000:3000"
environment:
- JWT_SECRET=${JWT_SECRET}
- ENCRYPTION_KEY=${ENCRYPTION_KEY}
- REDIS_HOST=redis
- ADMIN_USERNAME=${ADMIN_USERNAME:-}
- ADMIN_PASSWORD=${ADMIN_PASSWORD:-}
volumes:
- ./logs:/app/logs
- ./data:/app/data
depends_on:
- redis
redis:
image: redis:7-alpine
container_name: claude-relay-redis
restart: unless-stopped
volumes:
- redis_data:/data
volumes:
redis_data:

The Compose file above defines two services: claude-relay and redis. Let’s explain each field:

  • Images and Containers: The claude-relay service uses our pulled official image weishaw/claude-relay-service:latest, naming the container claude-relay-service for easy identification. The redis service uses the official redis:7-alpine lightweight image as the backend database. Both services have restart: unless-stopped set to ensure automatic restart on abnormal exits, guaranteeing high availability.

  • Network Ports: ports maps the container’s internal port 3000 to the host’s port 3000, meaning after startup you can access Claude Relay Service’s API and web management interface via http://<server-IP>:3000.

  • Environment Variables: environment lists the environment variables required by Claude Relay Service. ${JWT_SECRET} and ${ENCRYPTION_KEY} read corresponding values from our .env file. REDIS_HOST=redis specifies the service should connect to the container named redis as its database. ADMIN_USERNAME and ADMIN_PASSWORD use ${VAR:-} syntax, meaning if these variables are provided in .env, use those values; otherwise leave empty for automatic admin account creation. By centralizing configuration through environment variables, no sensitive information is hardcoded in images, and configuration changes are convenient.

  • Volume Mounting: Claude Relay Service writes logs and data to /app/logs and /app/data directories within the container respectively. We mount the host’s ./logs and ./data directories to corresponding container paths via volumes, achieving log and data persistence. This ensures that even if containers restart or upgrade, previous conversation content, account configurations, and other data won’t be lost.

  • Service Dependencies: depends_on: - redis indicates the Claude Relay service should wait for the Redis service to be ready before starting. This ensures the application can successfully connect to the database on startup without worrying about startup order issues.

  • Named Volumes: The volumes: redis_data: at the bottom defines a persistent volume for storing Redis data files. The Redis container mounts this to its /data path, allowing Redis data to be shared/persisted across containers.

With the configuration files ready, you can see they already cover admin account initialization, data persistence, built-in Redis, health restarts, and more. Docker Compose helps us handle all these deployment complexities in one go – worry-free and effortless.

4. Start Services: In the directory containing the above files, execute:

Terminal window
docker-compose up -d

Docker will pull the Redis image and start both containers. On first startup, Claude Relay Service will automatically initialize admin credentials. If we didn’t preset admin credentials in .env earlier, we can get the default account by checking logs or files:

Terminal window
docker logs claude-relay-service # Find initial admin account in container logs
# Or check mounted data files
cat ./data/init.json

The logs or files will display the admin username (typically defaults to cr_admin) and a randomly generated password. With admin credentials in hand, open http://<server-IP>:3000/web in your browser to access the web management interface. Enter the admin account to log in and start configuring your Claude Relay Service!

5. Add Claude Accounts: After logging into the admin backend, first integrate Claude official accounts into the system. In the “Claude Accounts” tab, click “Add Account”, then click “Generate Authorization Link”. The system will redirect to Anthropic’s official OAuth page, prompting you to log in and authorize. Use the Claude account you want to share to complete authorization, which will return an authorization code. Paste this back into Claude Relay Service’s add account page to successfully bind the account. The entire process is similar to using third-party apps to log into Google – secure and convenient. Pro tip: If your server is in regions with restricted access, this step may require VPN assistance, otherwise you won’t be able to open Anthropic’s authorization page.

6. Distribute API Keys: With the account pool ready, you can create individual API Keys for team members. In the admin backend, go to the “API Keys” tab, click “Create New Key”, name it (e.g., “Zhang San’s Key”), then generate. You can also set permissions and quotas for that key during creation, such as maximum requests per minute, concurrency limits, available models, client binding, etc. After saving, the system generates a random API key string. Team members can then use this key to call Claude Relay Service’s API endpoints, and the relay service will query Claude on their behalf.

After completing these steps, a fully functional Claude team sharing relay service is successfully deployed! Wasn’t the entire process quite streamlined? With Docker Compose, we barely need to manually configure complex environments – one command starts all services. The official team thoughtfully considered automatic initialization and data persistence in the Compose template, making it ready to use out of the box.

To maximize Claude Relay Service’s effectiveness in team collaboration, here are some lessons learned to share:

  • Smart Account Pool Planning: Use multiple Claude accounts to build your account pool, ensuring they have the same subscription tier (e.g., all Claude Pro/Max subscribers) so rotation won’t be hindered by individual account performance limitations. Account quantity can be adjusted based on team size and request frequency – more people means more accounts for stability. Don’t worry about account idle time; as they say, “multiple Claude accounts on patrol means no fear of bans” – even if individual accounts get temporarily suspended by risk controls, backup accounts can step in to maintain uninterrupted service.

  • Leverage Usage Statistics: Administrators should regularly check Claude Relay backend’s usage statistics to understand each API Key’s request volume and token consumption. This helps maintain transparent accounting within the team: when everyone splits Claude subscription costs, everyone has a clear “understanding of the books.” If you notice abnormally high request volumes during certain periods, you can communicate promptly or adjust rate limits to prevent one person from “monopolizing” resources and affecting others.

  • Set Access Controls: Claude Relay Service supports rich usage restrictions for each API Key. Make good use of these features – for example, limiting individual users to no more than N requests per minute, or allowing only specific clients/applications to use them – to prevent misuse and abuse. Especially when opening access to more people or integrating with third-party applications, be sure to configure proper rate limiting and concurrency controls to protect backend Claude accounts from overload and prevent team conflicts over resource competition.

  • Monitor Network and Latency: Recommend deploying the service in regions with fast access to Claude servers (such as North America). If your team primarily uses it domestically, consider choosing relay routes friendly to domestic users. For example, deploy in the US but use optimized return networks to reduce latency during API calls. Based on practice, some domestic cloud providers’ overseas machines may be blocked by Claude’s Cloudflare firewall, so pay attention to official channel announcements or community feedback.

  • Stay Updated: This project is very active with continuously improving features (such as recently added Claude-1.2 model support, etc.). Recommend regularly following the project’s GitHub homepage or Telegram announcement channels. Docker users can periodically docker pull to get the latest images, then restart services to upgrade. Staying current allows you to enjoy more stable performance and latest feature capabilities.

Final reminder: Using Claude Relay Service constitutes unofficial Claude API access – please be sure to comply with Anthropic’s terms of service and avoid abuse that could risk your accounts. Self-hosted services give us greater freedom but also mean taking responsibility for security and compliance ourselves. Establish good usage guidelines within your team to ensure long-term “happy Claude usage”!

With Claude Relay Service, we no longer need to rack our brains over team Claude account sharing. Whether you’re unable to directly access Claude due to regional restrictions or want to split the cost of expensive Claude Max subscriptions with teammates, this open-source project provides a flexible, reliable, secure, and private solution. We’ve detailed its core features: multi-account pools, OpenAI interface compatibility, custom API keys, OAuth account addition, and more, showing you clearly how it meets team collaboration needs. At the same time, we’ve demonstrated Docker Compose deployment step-by-step, from configuring environment variables to starting services – we believe even readers who aren’t DevOps experts can follow along and quickly set up their own Claude relay station.

It’s easy to imagine that with Claude Relay Service, late-night coding sessions no longer fear Claude account quota depletion, and colleagues don’t need to each open separate accounts and pay duplicate fees. Everyone shares one “Claude resource pool,” taking what they need while keeping everything transparent and clear – truly achieving cost savings and peace of mind!

Unlock Claude Code's Thinking Modes: From 'think' to 'ultrathink'

When used well, think is your secret weapon for breaking through bottlenecks; when used poorly, Claude works like it “left its brain at home”.


You ask Claude to help analyze a problem, and it gives you an answer in three sentences.

It looks “decent enough”, but when you try to implement it, everything goes wrong, full of bugs.

Many people think Claude isn’t capable, but the truth is: you didn’t let it think properly!


Claude’s Hidden Skill: Thinking Gear Adjuster

Section titled “Claude’s Hidden Skill: Thinking Gear Adjuster”

Claude Code actually has a built-in “thinking accelerator” tool (called Think Tool), but you have to trigger it yourself.

GearKeywordsThinking Token LimitThinking Depth
NONENo keywords added0 TokensQuick execution, almost no thinking
BASICthink / 想4K TokensBasic thinking, quick rough planning
MIDDLEthink hard / 好好想10K TokensModerate thinking, suitable for complex tasks
HIGHESTultrathink / 仔细思考32K TokensDeepest thinking, suitable for tough challenges

This isn’t mysticism, but real settings written in Claude Code’s engineering code.

Add keywords, and it really will think for a while longer!


Don’t worry that Claude can’t understand Chinese, its trigger logic also supports our native language:

  • HIGHEST (32K): 仔细思考、深思、多想一会
  • MIDDLE (10K): 好好想、多想想
  • BASIC (4K): 思考、想

For example, if you say “Think carefully about this problem before giving me a plan” — Claude immediately switches to the highest gear, allocating the most thinking time!


Practical Advice: How to Use Most Effectively?

Section titled “Practical Advice: How to Use Most Effectively?”

Of course, here are typical usage scenario examples for each thinking gear, concise and clear, ready to use directly 👇


🧠 ultrathink Example: Breaking Down Complex Product Features

Section titled “🧠 ultrathink Example: Breaking Down Complex Product Features”

Prompt: I want to develop a “Smart Daily Report Assistant” that can automatically aggregate today’s key events from Slack, Notion, GitHub, and help me generate daily report drafts. Please think carefully (ultrathink) about this problem first, then output a module division, data flow, and API interface design.

📌 Use Cases: Multi-system integration, vague requirements, need deep architectural thinking


🧠 think hard Example: Evaluating Multiple Technical Solutions

Section titled “🧠 think hard Example: Evaluating Multiple Technical Solutions”

Prompt: I want to choose a database solution for a multi-user collaborative document application. Please think hard about whether to choose PostgreSQL + Redis or MongoDB + Kafka, output a comparative analysis and give recommendation reasons.

📌 Use Cases: Multiple routes available, need comparative analysis


🧠 think Example: Small Task Logical Planning

Section titled “🧠 think Example: Small Task Logical Planning”

Prompt: I’m planning to write a script that downloads all image links from a Markdown file and renames them. Please think about how to do this first, which Python libraries are most suitable, then write the code for me.

📌 Use Cases: Task isn’t complex, just need a simple run-through of the approach


Prompt: I’ve already written the usage instructions for this AI summary tool. Please optimize the following text format into a README.md file, output the result directly, no need to overthink.

📌 Use Cases: Clear requirements, just need execution, no planning needed


Section titled “🚀Recommended Usage Pattern: “Explore, Plan, Code, Commit””

Claude Code officially recommends a 4-step workflow:

  1. Explore: Let Claude read files first, but don’t write code
  2. Plan: Use ultrathink to make detailed plans (core step)
  3. Code: Write code based on the plan, self-check reasonableness
  4. Commit: Generate Pull Request and changelog

📌 Key Point: Step #2 Plan must add keywords to trigger “thinking gears”, otherwise it might skip deep thinking and start working directly!


🧠It’s Not That Claude Isn’t Smart, You Just Didn’t Let It Use Its Brain

Section titled “🧠It’s Not That Claude Isn’t Smart, You Just Didn’t Let It Use Its Brain”

Claude is very capable, but if you don’t give it “thinking space”, it can only respond hastily.

Use think, think hard, think harder, ultrathink well, and you can not only improve output quality but also solve complex problems in one go.

Do you think this design is clever? Have you ever fallen into the trap of “Claude starting work without thinking clearly”? Welcome to share your experience in the comments 👇

Run Claude Code on OpenAI-Compatible Models: A Hands-On Guide to claude-code-proxy

claude-code-proxy automatically converts the Anthropic API used by Claude Code to an OpenAI-compatible API. In practice that means you can switch Claude Code to GPT-4o, Gemini, Ollama—or any OpenAI-style model—without touching your source code. You’ll cut costs and still keep function calling and streaming responses.


  • The stock Claude Code CLI only talks to Anthropic’s endpoint—it’s expensive and often rate-limited. A self-hosted proxy removes that bottleneck.
  • Plenty of “translation” scripts exist, but most don’t support function calling or smart model mapping, and they’re fiddly to configure.

Full support for /v1/messages, including on-the-fly conversion of Base64 images.

2.2 Switch between cloud and local models at will

Section titled “2.2 Switch between cloud and local models at will”

Adapters for OpenAI, Azure OpenAI, Ollama and any other OpenAI-compatible service are built in.

  • haiku → SMALL_MODEL
  • sonnet → MIDDLE_MODEL
  • opus → BIG_MODEL

Flip one environment variable, done—no code edits.

Claude Code continues to “write code, call APIs, stream output” on the new backend.

Timeouts or token overflows are caught and returned with human-readable messages.


Commands below assume macOS/Linux

Terminal window
# Super-fast with uv
uv sync
# Or the classic way
pip install -r requirements.txt
Terminal window
cp .env.example .env
# Open .env and fill in OPENAI_API_KEY etc.

Required: OPENAI_API_KEY
Optional security gate: ANTHROPIC_API_KEY (requests must match if set).

Terminal window
python start_proxy.py
# or uv run claude-code-proxy

Default listen address: 0.0.0.0:8082; default log level: WARNING.

Terminal window
export ANTHROPIC_BASE_URL=http://localhost:8082
export ANTHROPIC_API_KEY=anything # any string if the proxy doesn’t check
claude # Happy Vibe Coding!

Edit .env on the fly:

Terminal window
# Use Azure
OPENAI_BASE_URL="https://your-azure-endpoint"
BIG_MODEL="gpt-4"
# Use local Llama 3
OPENAI_BASE_URL="http://localhost:11434/v1"
BIG_MODEL="llama3.1:70b"

No need to restart Claude Code.

Claude’s official client respects HTTP(S)_PROXY, so you can chain it with claude-code-proxy.

Commit .env and docker-compose.yml to a private repo and spin up the proxy in CI.


  1. 401 Unauthorized – Ensure ANTHROPIC_API_KEY matches on both sides, or disable the check.
  2. Model name not recognised – Verify it contains haiku/sonnet/opus, or set BIG_MODEL manually.
  3. High latency – Enable GPU for local Ollama; in the cloud start uvicorn with --workers 4.

With claude-code-proxy Claude Code becomes a true Swiss-army knife: Vue on the front end, Gemini on the back end, docs written with GPT-4o—all through one CLI port. Fire it up and tell me which model combo you like best!


Round-tripping PDFs with Claude Code

In daily work, contracts, agreements, BLE communication specifications… companies are never short of PDFs. They look beautiful but are a nightmare to edit: copy-paste gets messy, formatting goes haywire. This article shares a practical “reverse PDF → Markdown → PDF” workflow using Claude Code in three steps, while maintaining an editable Word version.


  • Only PDF left, Word lost → Cannot maintain
  • Partners only accept PDFs → Format must be unified
  • Want to add new APIs/tables → Need text-editable format

Claude Code perfectly fills this gap.


PDF → Markdown (Editable) → Update → PDF/Word The core is leveraging Claude Code’s multimodal parsing and formatting capabilities.


Goal: Preserve titles, tables, image references, convert to clean .md in one click.

Recommended Prompt

Please fully parse this PDF into Markdown:
1. Preserve all heading levels (#-###)
2. Display tables in Markdown syntax
3. Use `![alt](placeholder)` for images
4. Ignore footers and page numbers
Return complete Markdown text

Claude Code will automatically recognize the PDF structure and generate a clear Markdown document.

# CGM BLE Communication Protocol v2.1
## 1. Data Frame Structure
| Field | Length(Byte) | Description |
|-------------|-------------|-----------------------|
| Frame Head | 2 | Fixed 0x55AA |
| Length | 1 | Subsequent byte length |
| Cmd | 1 | Function code |
| Payload | N | Business data |
| CRC16 | 2 | Low byte first |
![Frame Structure Diagram](fig/frame.svg)
> **Note**: All multi-byte fields are Little-Endian.

Goal: Add latest APIs, correct descriptions, make documentation live again.

Automatic Code Analysis

Please review this Markdown and find all API code blocks:
- Check for parameter naming consistency
- Mark potential errors and provide improvement suggestions

Claude Code will automatically analyze code blocks in Markdown, find potential issues, and suggest improvements.

Found 2 potential issues:
1. "Cmd=0x07 upload glucose" inconsistent with API list description (list says 0x08)
2. "CRC16 checksum algorithm" doesn't specify polynomial, could reference ITU-T X.25
Improvement suggestions:
- Update API list or correct documentation
- Add polynomial 0x1021 in <2.3 CRC Calculation> section

Or manually add details

### /device/sync
| Field | Type | Required | Description |
|---------|------|----------|------------------------|
| uid | str | Y | Device unique ID |
| ts | int | Y | Unix timestamp(seconds)|
| glucose | int | Y | Current glucose(mg/dL) |

Goal: Output updated documentation as standard PDF for partner submission.

Recommended Prompt

Please render this Markdown as a beautifully formatted PDF:
- Use A4 pages
- Auto-generate table of contents from headings
- Center tables horizontally

Claude Code will generate a uniformly formatted PDF document.


Need a Word version for the company? Use single-page HTML as a workaround!

Markdown ➜ Single-file HTML

Convert the following Markdown to self-contained (inline CSS) single-file HTML,
convenient for Word to open without dependencies.

Claude Code will generate an HTML file containing all styles.

<!DOCTYPE html><html><head>
<meta charset="utf-8">
<style>
body{font-family:"Microsoft YaHei";}
h1,h2{margin:1em 0;}
table{border-collapse:collapse;width:100%;}
td,th{border:1px solid #ccc;padding:6px;text-align:center;}
</style>
</head><body>
<h1>CGM BLE Communication Protocol v2.2</h1>
<h2>1. Data Frame Structure</h2>
<table>
<tr><th>Field</th><th>Length(Byte)</th><th>Description</th></tr>
<tr><td>Frame Head</td><td>2</td><td>Fixed 0x55AA</td></tr>
...
</table>
</body></html>

Then:

  1. Word opens HTML → Save as DOCX/PDF
  2. Get locally editable Word + final PDF, two birds with one stone.

Through Claude Code, bring out-of-control PDFs back to the editable world, then painlessly output standard PDF/Word, solving both “format unity” and “content maintainability” pain points.

What other stubborn PDFs do you have that need reviving? Leave a comment and chat—maybe the next article will cover your scenario!

Make Claude Code Smarter: Auto-Generate Six Spec Docs with the Specs Generator

Tired of being led astray by “vibe-coding”?

This open-source tool Claude Code Specs Generator equips Claude Code with a “documentation generator” — automatically producing 6 core documents that clearly outline business, technology, architecture, and tasks, making Claude read the manual first before writing code.


  • AI ≠ Mind Reading When context is messy, Claude often “takes liberties” rewriting dependencies or reinventing the wheel. Amazon’s Kiro IDE solved the same pain point with “Spec-Driven Development”, and practice proves: generating specs first, then code, dramatically reduces error rates.

  • Team Collaboration Saves 30% Communication Costs Unified product.md, tech.md, structure.md allow newcomers to complete code orientation in 10 minutes, reducing verbal handoffs.

  • Claude Reasoning More Accurate Include these 6 documents in CLAUDE.md, and AI loads them with every response, avoiding “memory gaps”.


CategorySpecific FilesPurpose
Steeringproduct.md / tech.md / structure.mdBusiness goals, tech stack, directory standards
Specsdesign.md / requirements.md / tasks.mdArchitecture design, user stories, development tasks

System analyzes your repository & documentation, one-click /specs-create auto-generates everything.

  • /specs-create Initial spec creation
  • /specs-init Refresh context (auto /clear → /init)
  • /refresh-specs Incremental updates based on recent git commits

3️⃣ Seamless Integration with Claude Code

Section titled “3️⃣ Seamless Integration with Claude Code”

After specs are written, the generator writes file paths into CLAUDE.md. Next time you type @claude fix tests in terminal, Claude will reference the latest specs for execution.


  • New Project From Zero to One Pull an empty repository, run /specs-create, instantly get “product-tech-structure” three direction documents, then iterate design and tasks.
  • Legacy Project Governance Wrote lots of code and want to add documentation? Same one-click approach. The generator scans existing PRD/TODO files and merges content.
  • Continuous Delivery Trigger /refresh-specs CI script with every PR, letting specs evolve alongside code.

  1. Installation

    Terminal window
    npx @kellemar/claude-code-specs-generator
    • No global installation needed, creates .claude/ and specs/ directories in current project after execution.
  2. One-Click Spec Generation

    Terminal window
    /specs-create

    Parses code and old documentation, auto-generates 6 Markdown files and updates CLAUDE.md.

  3. Load Context

    Terminal window
    /specs-init

    Essentially /clear → /init combination, ensuring Claude carries latest Specs in every round.

After setup, your project will include:

your-project/
├── .claude/
│ └── steering/
│ ├── product.md # Product vision and business goals
│ ├── tech.md # Technology stack and constraints
│ └── structure.md # Code organization patterns
├── specs/
│ ├── design.md # Technical architecture
│ ├── requirements.md # User stories and acceptance criteria
│ └── tasks.md # Current development tasks
└── CLAUDE.md # Updated with document references

Specs Generator = “Kiro-flavored” Free Plugin No need to switch to a new IDE, you can enjoy the security of spec-driven development in your existing Claude Code workflow. Try /npx @kellemar/claude-code-specs-generator now, and let both AI and humans take fewer detours!


🤔 Would you add it to your own project? Leave a comment and share which step you’d most like to automate!

(Next article we’ll break down how to turn Specs into Mermaid diagrams, stay tuned!)

Claude Code + Kimi K2: The 1‑Line Env Hack for AI Coding

This article shows you how to use one environment variable to replace Claude Code in your terminal with Moonshot’s Kimi K2 — cheap, fast, and no need to “climb mountains”. Here’s the quick conclusion first, followed by step-by-step details that you can copy and follow.


  • Claude Code’s Agent workflow is incredibly satisfying, but by default it only connects to Anthropic’s official models, which is expensive and has network issues.
  • Kimi K2 publicly provides Anthropic-compatible API, starting at 0.02 yuan per 1k tokens, about an order of magnitude cheaper than the official version; long context and coding capabilities are also solid.
  • Just apply for a Moonshot API Key in advance and fill in ANTHROPIC_AUTH_TOKEN and ANTHROPIC_BASE_URL, and Claude Code will treat K2 as the “genuine Claude” without needing to modify source code or use proxies.

Required SoftwareMinimum Version
Node.js18+
npm8+
Git2.20+

Verify with node -v in terminal. If below 18, please upgrade to LTS version.

Then install Claude Code globally:

Terminal window
npm install -g @anthropic-ai/claude-code
claude --version # If you can see the version number, you're good

  1. Visit Moonshot Console https://platform.moonshot.cn/console/api-keys, create a new Key (prefix sk-).

  1. Copy and save it securely, as you won’t be able to view it again.

Terminal window
export ANTHROPIC_AUTH_TOKEN=sk-your-key
export ANTHROPIC_BASE_URL=https://api.moonshot.cn/anthropic
claude # Now all requests go through Kimi K2
Terminal window
set ANTHROPIC_AUTH_TOKEN=sk-your-key
set ANTHROPIC_BASE_URL=https://api.moonshot.cn/anthropic
claude

TIP: For permanent effect, add the two export/set commands to ~/.bashrc, ~/.zshrc, or “System Environment Variables”.


Open a new terminal and run claude, then ask:

/status

If you see Anthropic Base URL: https://api.moonshot.cn/anthropic, it means you’re connected to K2. You can also have it write some code, and you’ll notice significant improvements in speed and cost.

Regularly check the Moonshot console to monitor K2 usage and costs.


SymptomSolution
”401 Unauthorized” errorConfirm that ANTHROPIC_AUTH_TOKEN has the sk- prefix and hasn’t expired.
Prompt to login to AnthropicAdd export ANTHROPIC_API_KEY=NOT_NEEDED to bypass the check.
Want to temporarily switch back to official Claudeunset ANTHROPIC_BASE_URL; set it back to reconnect to K2.
Proxy software conflictsIf you have proxy scripts running locally (like kimi-cc), ensure ports aren’t conflicting, or switch to the official direct connection method above.

  • Moonshot K2: Input 1k tokens 0.02 yuan, output 0.06 yuan; at least 10× cheaper than official Claude Opus.
  • In practice, writing a small web game costs ≈ 0.6 yuan, truly “1 yuan outsourcing”.

Turn the pain points of “expensive + network issues” into the sweet spot of “cost-effective + direct connection” — just two environment variables, and Claude Code instantly switches to Kimi K2, upgrading your terminal to a domestic large model engine.

Have fun, and don’t forget to type :set language zh in claude to make the AI speak Chinese too; more new tricks in the comments!

Claude Code Templates: One-Click Setup & Real-Time Monitoring for Your Claude Code

claude-code-templates is an open-source CLI tool created by developer Daniel Avila (davila7), designed to help developers quickly configure and monitor Claude Code. It can generate project configurations with one click, analyze existing settings, and display runtime status in real-time, making it perfect for use with Claude Code .


  • Supports JavaScript/TS (including React, Vue, Angular, Node.js), Python (Django, Flask, FastAPI), and generic templates. Other languages like Go and Rust are coming soon .
  • Supports interactive startup and can also achieve one-click configuration through parameters like --language, --framework, --yes, --dry-run, --directory .
  • Installation command: npx claude-code-templates@latest, no global installation required. Can also be installed globally: npm install -g claude-code-templates .
Terminal window
npx claude-code-templates@latest
██████╗██╗ █████╗ ██╗ ██╗██████╗ ███████╗
██╔════╝██║ ██╔══██╗██║ ██║██╔══██╗██╔════╝
██║ ██║ ███████║██║ ██║██║ ██║█████╗
██║ ██║ ██╔══██║██║ ██║██║ ██║██╔══╝
╚██████╗███████╗██║ ██║╚██████╔╝██████╔╝███████╗
╚═════╝╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
██████╗ ██████╗ ██████╗ ███████╗
██╔════╝██╔═══██╗██╔══██╗██╔════╝
██║ ██║ ██║██║ ██║█████╗
██║ ██║ ██║██║ ██║██╔══╝
╚██████╗╚██████╔╝██████╔╝███████╗
╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
████████╗███████╗███╗ ███╗██████╗ ██╗ █████╗ ████████╗███████╗███████╗
╚══██╔══╝██╔════╝████╗ ████║██╔══██╗██║ ██╔══██╗╚══██╔══╝██╔════╝██╔════╝
██║ █████╗ ██╔████╔██║██████╔╝██║ ███████║ ██║ █████╗ ███████╗
██║ ██╔══╝ ██║╚██╔╝██║██╔═══╝ ██║ ██╔══██║ ██║ ██╔══╝ ╚════██║
██║ ███████╗██║ ╚═╝ ██║██║ ███████╗██║ ██║ ██║ ███████╗███████║
╚═╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚══════╝╚══════╝
🚀 Setup Claude Code for any project language 🚀
🚀 Welcome to Claude Code Templates!
? What would you like to do? (Use arrow keys)
📊 Analytics Dashboard - Monitor your Claude Code usage and sessions
🔍 Health Check - Verify your Claude Code setup and configuration
⚙️ Project Setup - Configure Claude Code for your project
  • Launch command --analytics, opens local dashboard (default http://localhost:3333), displaying Claude session count, token usage, session history, project activity, etc.
  • Supports CSV/JSON export, runs completely locally with no data leakage .
  • Reddit users comment: “Real-time monitoring … runs completely local (localhost:3333)… Token usage insights have been eye-opening!” .
  • Use --health-check to verify system environment, Node.js version, network connectivity, Claude Code configuration, hooks, MCP, etc., providing visual check results and recommendations .

Deep analysis can be performed through the following commands:

Terminal window
npx claude-code-templates --commands-stats
npx claude-code-templates --hooks-stats
npx claude-code-templates --mcps-stats

Commands output command file statistics, hook enable status, MCP service status, AI optimization suggestions, etc. .

Supports dry-run mode to preview operations, automatically backs up existing configurations, prompts for confirmation before changes, and can be canceled at any time. --yes can skip prompts for automatic execution .


Terminal window
npm install -g claude-code-templates
npx claude-code-templates

Enter target project path, complete configuration in one step.

Terminal window
npx claude-code-templates \
--language javascript-typescript \
--framework react \
--yes

For Python + Django, use similarly: --language python --framework django --yes .

Terminal window
npx claude-code-templates --analytics
Terminal window
npx claude-code-templates --health-check
Terminal window
npx claude-code-templates --commands-stats
npx claude-code-templates --hooks-stats
npx claude-code-templates --mcps-stats

  • Time and effort saving: What previously required manual configuration of .claude/, CLAUDE.md, commands, MCP, hooks, now takes just seconds.
  • Real-time visualization: Analytics Dashboard provides clear session monitoring and token usage at a glance.
  • Standards + Security: Automatic backup + dry-run + confirmation mechanism ensures project configuration safety.
  • Optimization suggestions: Command analysis and hook/MCP stats help you optimize and form best practices.

Reddit users praise its Dashboard functionality:

“Real-time monitoring of all Claude Code sessions… Token usage charts and project activity breakdown… runs completely local” .

The community is also hotly discussing new feature requests, such as support for SwiftUI project templates .

Additionally, the author just launched an online template preview page where users can browse templates through the web, copy installation commands, and contribute their own templates to the community .


claude-code-templates is summed up in one sentence: Make Claude Code “ready-to-use, monitorable, and optimizable.” Suitable for teams or individuals who pursue efficient development workflows, like dashboard views, and value configuration security. Next, the project will support more languages/frameworks like Go and Rust, and open up online community template submission portals to build the ecosystem together.


Hope this article helps you quickly understand and get started with claude-code-templates, making your Claude Code development more relaxed, visual, and professional. Open your terminal and try:

Terminal window
npx claude-code-templates --analytics

Start a smarter development journey ✨

Sniffly: Visualizing Your Claude Code Usage Patterns with Dashboards

One command to instantly transform boring Claude Code jsonl logs into visual insights.


Sniffly is a local tool open-sourced by Chip Huyen that specifically parses .jsonl logs generated by Claude Code and creates an interactive web dashboard, helping you quickly answer three questions:

What you want to know…Sniffly provides…
What did I actually use Claude Code for?Usage Stats: command counts, file operations, average steps, etc.
What errors does Claude Code make most often?Error Breakdown: visualize errors by type and percentage
Why did a certain conversation go wrong?Message History: replay complete context step by step

All calculations are done locally without uploading any conversations or code, privacy-friendly.


Environment requirements: Python 3.10+

Terminal window
# ✅ Temporary trial (no installation required)
uvx sniffly@latest init
# ✅ Global installation
uv tool install sniffly@latest # or pip install sniffly
sniffly init # First scan and start service

By default, it opens the dashboard at http://localhost:8081 in your browser. You can also change the port or disable auto-open via command line:

Terminal window
sniffly config set port 8090
sniffly config set auto_browser false

FeatureHighlights
Usage StatsBar charts/line graphs for command counts, conversation length, average steps, most time-consuming commands, etc.
Error BreakdownStatistics for FileNotFound, FuncNotFound, Timeout and other error percentages
Message HistoryLike a “recording tape” replay, synchronously showing your code diffs
Sharable DashboardOne-click generation of private/public links to share insights with teammates

Chip Huyen shared two surprising discoveries in her launch post:

  1. “Content Not Found” is the most common error, accounting for 20-30% —— Claude Code often looks for non-existent files/functions.
  2. After optimizing project structure, average command steps dropped from 8 to 7 —— Just improving discoverability had immediate efficiency gains.

Similarly, you can use Sniffly to find your own “invisible efficiency black holes” and make targeted improvements.


GoalCommand / Operation
Switch project directory to analyzesniffly init --project /path/to/project
Limit memory usagesniffly config set cache_max_mb_per_project 200
Share stats only, hide command textDashboard ▶︎ Share ▶︎ check Hide Commands
Align logs & Git commit timelinePass git repo path to sniffly init, timeline auto-merges

If you’re also using Claude Code for Vibe Coding but struggling with:

  • Scattered logs, hard to focus on issues
  • Many error types, don’t know what to optimize first
  • Want to show AI programming ROI to your team but lack visual evidence

Then try Sniffly —— One command to help you “sniff out” the value hidden in logs.

Open source address, documentation, and demo:


Take action! Let Sniffly become your Claude Code “black box,” starting today to quantify every gain and loss in AI programming.

Claude Code Alternative: DeepSeek R1 + Kimi K2 Quick Start Guide

Claude Code Router (CCR) https://github.com/musistudio/claude-code-router is a “multi-model router” tailored for Claude Code users: it listens locally to Claude Code’s standard requests, then forwards them to DeepSeek-R1, Kimi K2, and any other LLMs according to your routing strategy. It’s compatible with OpenAI-style APIs and can add “transformers” for different models to adapt parameters and responses. This article first provides an overview of CCR’s core mechanisms, then demonstrates step-by-step how to integrate DeepSeek R1 and Kimi K2, giving you everything you need for “multi-model collaborative coding.”


  • CCR describes Provider → Model → Transformer → Routing Rules through ~/.claude-code-router/config.json, allowing Claude Code to hot-switch backend models in VS Code/terminal as usual using /model.
  • Built-in pluggable transformers for DeepSeek, OpenRouter, Gemini, MaxToken, etc., allowing multiple transformations to be stacked on a single model.
  • Supports both CLI and GitHub Actions modes; combined with Actions, you can leverage DeepSeek’s 25% nighttime rates for “early morning batch processing.”
Terminal window
npm i -g @anthropic-ai/claude-code # Install Claude Code
npm i -g @musistudio/claude-code-router
ccr code # Start Claude Code with CCR

  1. Apply for a key in the DeepSeek Platform console and record the sk-xxx.
  2. The official API is https://api.deepseek.com/chat/completions, fully compatible with OpenAI SDK.
  3. R1 latest version number deepseek-r1-250528 (VolcEngine mirror provides 128K context).
{
"Providers": [
{
"name": "volcengine",
"api_base_url": "https://ark.cn-beijing.volces.com/api/v3/chat/completions",
"api_key": "sk-your-key",
"models": ["deepseek-r1-250528"],
"transformer": { "use": ["deepseek"] }
}
],
"Router": {
"think": "volcengine,deepseek-r1-250528"
}
}
  • The deepseek transformer automatically limits max_tokens to 8192 and is compatible with R1’s lack of tool_choice support.
  • Nighttime (00:30 – 08:30 UTC+8) R1 calls cost only 25% of daytime rates → suitable for large-scale testing/refactoring scripts.

Type in Claude Code:

/model volcengine,deepseek-r1-250528

This immediately switches the next conversation to use DeepSeek R1, inheriting the 128K context window.


  • Moonshot AI’s latest open-source MoE model, 1T total parameters / 32B activated experts, excelling at code generation and agent calls.
  • SiliconFlow provides 16384 max_tokens quota with high-concurrency, low-latency inference services, suitable for long-chain code analysis.
  • Enter siliconflow.cn console, enable moonshotai/Kimi-K2-Instruct and get the token.
  • Can also use OpenRouter’s unified compatible endpoint https://openrouter.ai/api/v1/chat/completions.
{
"Providers": [
{
"name": "siliconflow",
"api_base_url": "https://api.siliconflow.cn/v1/chat/completions",
"api_key": "sk-your-token",
"models": ["moonshotai/Kimi-K2-Instruct"],
"transformer": {
"use": [
["maxtoken", { "max_tokens": 16384 }]
]
}
}
],
"Router": {
"longContext": "siliconflow,moonshotai/Kimi-K2-Instruct"
}
}
  • The maxtoken transformer prevents CCR from accidentally exceeding SiliconFlow’s 16K max_tokens limit.
  • If you want to feed K2 all 32K+ project documentation in the same session, first use /model siliconflow,moonshotai/Kimi-K2-Instruct, then paste the full text.

SiliconFlow’s official cURL examples only need to replace with CCR’s local port; CCR handles forwarding and field compatibility.


ScenarioRouter KeyRecommended Model
Bulk File RefactoringthinkDeepSeek-R1 (low cost + reasoning chain output)
Ultra-long Project README SummarylongContextKimi-K2 (16K context)
Nighttime Offline CIGitHub Actions + CCRDeepSeek-R1 (25% nighttime rates)
Local Inference/Offline Background Tasksbackgroundqwen-coder-2.5@Ollama (0 cost)

CCR’s /model provider,model command supports hot-switching anytime; you can also preset default models for different task channels in Router, achieving a pipeline of “use R1 for coding, use K2 for long text reading.”


  1. Slow response? DeepSeek’s official endpoint inference is relatively slow. If VS Code times out, enable UltraThink budget or switch to VolcEngine mirror.
  2. Context overflow? DeepSeek API defaults to 64K, the above example uses VolcEngine to expand to 128K; Kimi K2 is 16K, needs maxtoken protection.
  3. Wrong model name? CCR’s /model format must be provider,model, don’t forget the comma.
  4. Tool calls failing? R1 currently doesn’t support tool_choice. For function calls, fall back to DeepSeek V3, or add a tooluse transformer to V3 in CCR.

With Claude Code Router + DeepSeek R1 + Kimi K2, you can hot-switch between “reasoning power” and “long context” strengths in the same IDE: use K2 for long document reports during the day, switch to R1 for batch code migration at night, at less than one-tenth the cost of official Claude Max. Install CCR now and unlock your new multi-model coding experience!

Claude Code Development Tool: `claude-trace` Complete Recording Tool for Transparent Debugging

When using Claude Code to write code, have you ever wondered:

  • How does Claude understand your instructions?
  • What exactly is written in the system prompt?
  • What tools did Claude use? What raw data was returned?
  • What happens behind the API? How many tokens did the model use?

Now, with the open-source tool claude-trace, you can see all these “behind-the-scenes” details!


Install with just one command:

Terminal window
npm install -g @mariozechner/claude-trace

Start Claude Code and record the entire process:

Terminal window
claude-trace

Supports more options:

FeatureCommand
Start Claude + loggingclaude-trace
Include all requests (default only logs valid conversations)claude-trace --include-all-requests
Run Claude with specific parametersclaude-trace --run-with chat --model sonnet-3.5
Extract OAuth tokenclaude-trace --extract-token
Generate HTML session reportclaude-trace --generate-html logs.jsonl report.html
Auto-generate index + summaryclaude-trace --index

Using claude-trace, you can see in the generated HTML page:

  • ✅ Claude’s system prompt (hidden instructions)
  • ✅ All raw API request and response data
  • Tool definitions and outputs (like search/file reading)
  • ✅ Claude’s “thinking process” blocks
  • ✅ Token usage statistics (including cache hit situations)
  • ✅ Interactive HTML view + search index
  • ✅ JSONL raw logs (saved in .claude-trace/ folder)

Each run generates a self-contained HTML file, viewable locally without a server, perfect for team reviews, debugging, and archiving.


📊 Session Summary & Index Features (AI-Enhanced)

Section titled “📊 Session Summary & Index Features (AI-Enhanced)”

Through the claude-trace --index command, you can also auto-generate:

  • AI-generated summary titles and overviews for all logs
  • Indexed index.html file
  • Clickable historical session list

Manage all Claude conversation records like managing Notion!


If you match these tags, you’ll love it:

  • 💡 Deep users or plugin developers of Claude Code
  • 🧪 Need to debug Claude tool chains, system instructions, or log structures
  • 📁 Want to archive all Claude programming sessions
  • 🧠 Want to understand Claude’s real “thinking” process behind the scenes
  • ⚙️ Need to build automated testing or generate session review reports

Project repository: https://github.com/mariozechner/claude-trace


Summary:

claude-trace is an essential debugging tool for Claude Code users, letting you see inside the AI’s “black box.” Whether developing plugins, analyzing model responses, or building Claude engineering log systems, it brings tremendous convenience.

If you’re developing projects with Claude, give it a try and start your “Claude visual development journey” with one click!

Hands‑On with Vibe Kanban: Manage Claude, Gemini & Amp Tasks in One Board

Coding Agents (like Claude Code, Gemini CLI, Amp, etc.) are becoming increasingly important in engineering development. Teams are finding that the time spent on planning, reviewing, and coordinating these human tasks now exceeds the time spent writing code itself.

Vibe Kanban https://github.com/BloopAI/vibe-kanban is a new tool specifically designed to solve these collaboration workflow problems. Through its Kanban board interface, it allows you to:

  • Quickly switch between coding agents (Claude, Gemini, Amp, etc.);
  • Call multiple agents in parallel or series, automatically executing tasks;
  • Visualize task status, code reviews, and quickly launch Dev Servers;
  • Centrally manage agent MPC configurations to improve overall collaboration efficiency;
  • In the future, coding agents will be able to automatically create task tickets through MCP servers.

Vibe Kanban’s design philosophy is: When most code is written by AI, our human role becomes planning, reviewing, and coordinating. This is not just a trend, but a completely new way of development work.


  1. Pre-configure Agents For example, install and log into Claude Code, Gemini CLI, Amp, etc.

  2. Run command to start Vibe Kanban

    Terminal window
    npx vibe-kanban

    Automatically finds local port and opens browser (e.g., http://127.0.0.1:53046), entering the Kanban workspace.

  3. Configure Agents Initially, you need to add Agent MCP in Settings (e.g., Claude, Gemini, Amp tokens/paths), then you can freely switch agents in the UI to execute tasks.

  4. Create Project Create a new project in the Kanban interface, add Tasks, and you can start using it.


1. Multi-Agent Parallel or Serial Task Execution

Section titled “1. Multi-Agent Parallel or Serial Task Execution”

After switching to the corresponding agent, you can initiate multiple “Attempts” for the same task. Supports parallel execution (different branches/workspaces) and serial execution (waiting for the previous step to complete before proceeding). Execution status and logs are clear at a glance.

After each agent generates code, Vibe Kanban automatically displays diffs and execution output, providing a one-click Dev Server launch button for real-time preview.

Uses the common three-column Kanban layout (To Do, In Progress, Done), providing an intuitive view of task status and agent execution progress. You can create multiple attempts for a task and mark them as success/failure.

All agent configurations (e.g., Claude, Gemini tokens, run commands, etc.) are centrally managed in the Settings interface, making switching seamless.

5. Automatic Ticket Creation by Agents (MCP Integration)

Section titled “5. Automatic Ticket Creation by Agents (MCP Integration)”

Vibe Kanban has a built-in “Vibe Kanban MCP” server plugin that can automatically generate planner tickets through agents. For example:

“Plan a migration from AWS to Azure and create detailed tickets…” The agent will automatically break down tasks and create multiple Kanban cards, all done in the UI without manual intervention.

  1. Create a task in Kanban: e.g., “Implement user login page”;
  2. Select an agent (like Claude Code), click “New Attempt”;
  3. Agent automatically generates login page components and backend interfaces;
  4. You review the differences, run Dev Server, and verify the UI;
  5. If issues are found, modify instructions for the agent to retry, or re-select an agent (like Gemini);
  6. Mark the attempt as successful and move the task to Done.

The entire process requires no switching between command line windows, everything is operated within the UI, efficient and intuitive.


  • For individual developers: Greatly improves task startup, review, and debugging efficiency, making development smoother and more structured.

  • For small team collaboration: Agents automatically break down tasks, multiple attempts collaborate to complete, with independent Git worktrees, can connect to external MCP, suitable for team pipeline collaboration.

  • Investing in future capabilities: As agent capabilities continue to improve, Vibe Kanban can seamlessly adapt to different agents, allowing you to experience the latest model capabilities at any time.


⏳ Epilogue: AI is Coding, We are Collaborating

Section titled “⏳ Epilogue: AI is Coding, We are Collaborating”

Vibe Kanban is pioneering the new paradigm of “Agent-driven, human-orchestrated”. From the era of writing code to the era of orchestrating and reviewing code, we will unleash human creativity and make Agent Handoff more efficient with clearer processes. We recommend all developers who are testing or using coding agents in production to give it a try.

🎯 ccusage: Analyze Claude Code Usage Analytics

ccusage is a command-line tool created by open-source developer ryoppippi for analyzing locally generated JSONL files from Claude Code. It displays your token usage and corresponding costs through visual tables, helping you better manage usage habits and cost structures.

  • Simple functionality: Get daily, monthly, session, and billing block (5-hour) level token usage and cost distribution with just one command.
  • Real-time monitoring: Supports blocks --live for real-time monitoring of consumption rates and project progress within the current billing block.
  • Lightweight and efficient: Extremely small size (npm package ~1 MB), no dependency installation required, suitable for quick analysis.

  1. Cost awareness While Claude Code’s Max version offers unlimited usage, when switching to pay-per-use plans, ccusage can help you estimate daily and monthly costs, considering your “pain-free threshold.”

  2. Daily data tracking Through daily or monthly reports, timely grasp long-term token usage trends and identify any sudden spikes or anomalies.

  3. Session/billing block monitoring

    • Session level: Analyze single conversation token usage distribution and costs corresponding to projects and topics.
    • Block monitoring: Track consumption trends and rates within five-hour billing cycles (add --live for real-time observation).
  4. Multi-terminal sync analysis ccusage defaults to reading JSONL files from ~/.config/claude/projects/ and legacy path ~/.claude/projects/, enabling unified multi-device data analysis with cloud sync.

  5. Secondary visualization and tool integration Provides JSON output for integration with tools like Raycast, Neovim plugins, Go or Rust versions of real-time visualization tools (such as ccusage.nvim, ccusage-monitor, etc.).


No installation required, recommended to use execution environment directly:

Terminal window
# Recommended bunx (extremely fast)
bunx ccusage
# Or npx
npx ccusage@latest
# Or Deno
deno run -E -R=$HOME/.claude/projects/ -S=homedir -N='raw.githubusercontent.com:443' npm:ccusage@latest

Can also install globally:

Terminal window
npm install -g ccusage
# or
bun install -g ccusage

Terminal window
# Display default "daily" usage report:
ccusage
# Specify daily, monthly, session, or billing block reports:
ccusage daily
ccusage monthly
ccusage session
ccusage blocks
# Real-time monitoring of current billing block status:
ccusage blocks --live

More common parameters:

  • --since / --until: Analyze only specified date ranges
  • --breakdown: Show detailed consumption by models (like Opus, Sonnet)
  • --json: Output structured JSON for easy integration with other tools

Running ccusage daily outputs something like:

Quickly see daily total tokens, cache hit counts, and estimated costs.

Using ccusage blocks --live, the console will refresh in real-time showing current billing block accumulated tokens, burn rate, remaining budget, etc., like a CLI version “htop”.


  1. Cost estimates are simulated values: ccusage displays estimated costs based on token quantities and model pricing, which may slightly differ from actual bills.

ccusage is a compact but powerful CLI tool, suitable for developers and heavy users:

  • Quickly get daily/session/billing segment token consumption and cost analysis;
  • Real-time monitoring of current billing block progress;
  • Seamless integration with Raycast, Neovim, Go/Rust tools;
  • Cross-device analysis only requires syncing JSONL files.

Try npx ccusage daily and you’ll be surprised by your “spending trajectory” in Claude Code usage, becoming more conscious about budget management. Follow our channel to explore more efficiency secrets in the Claude ecosystem!


📌 Finally, if you want to learn more AI, Vibe Coding, and Claude usage tips, integration plugin recommendations, or advanced analysis, welcome to leave comments for discussion. Let’s build a smarter AI usage experience together!